aarch64: Add an aarch64_nat_target mixin class.

[binutils-gdb.git] / binutils / objdump.c

/* objdump.c -- dump information about an object file.
   Copyright (C) 1990-2022 Free Software Foundation, Inc.

   This file is part of GNU Binutils.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3, or (at your option)
   any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */


/* Objdump overview.

   Objdump displays information about one or more object files, either on
   their own, or inside libraries.  It is commonly used as a disassembler,
   but it can also display information about file headers, symbol tables,
   relocations, debugging directives and more.

   The flow of execution is as follows:

   1. Command line arguments are checked for control switches and the
      information to be displayed is selected.

   2. Any remaining arguments are assumed to be object files, and they are
      processed in order by display_bfd().  If the file is an archive each
      of its elements is processed in turn.

   3. The file's target architecture and binary file format are determined
      by bfd_check_format().  If they are recognised, then dump_bfd() is
      called.

   4. dump_bfd() in turn calls separate functions to display the requested
      item(s) of information(s).  For example disassemble_data() is called if
      a disassembly has been requested.

   When disassembling the code loops through blocks of instructions bounded
   by symbols, calling disassemble_bytes() on each block.  The actual
   disassembling is done by the libopcodes library, via a function pointer
   supplied by the disassembler() function.  */

#include "sysdep.h"
#include "bfd.h"
#include "elf-bfd.h"
#include "coff-bfd.h"
#include "progress.h"
#include "bucomm.h"
#include "elfcomm.h"
#include "demanguse.h"
#include "dwarf.h"
#include "ctf-api.h"
#include "getopt.h"
#include "safe-ctype.h"
#include "dis-asm.h"
#include "libiberty.h"
#include "demangle.h"
#include "filenames.h"
#include "debug.h"
#include "budbg.h"
#include "objdump.h"

#ifdef HAVE_MMAP
#include <sys/mman.h>
#endif

/* Internal headers for the ELF .stab-dump code - sorry.  */
#define BYTES_IN_WORD   32
#include "aout/aout64.h"

/* Exit status.  */
static int exit_status = 0;

static char *default_target = NULL;     /* Default at runtime.  */

/* The following variables are set based on arguments passed on the
   command line.  */
static int show_version = 0;            /* Show the version number.  */
static int dump_section_contents;       /* -s */
static int dump_section_headers;        /* -h */
static bool dump_file_header;           /* -f */
static int dump_symtab;                 /* -t */
static int dump_dynamic_symtab;         /* -T */
static int dump_reloc_info;             /* -r */
static int dump_dynamic_reloc_info;     /* -R */
static int dump_ar_hdrs;                /* -a */
static int dump_private_headers;        /* -p */
static char *dump_private_options;      /* -P */
static int no_addresses;                /* --no-addresses */
static int prefix_addresses;            /* --prefix-addresses */
static int with_line_numbers;           /* -l */
static bool with_source_code;           /* -S */
static int show_raw_insn;               /* --show-raw-insn */
static int dump_dwarf_section_info;     /* --dwarf */
static int dump_stab_section_info;      /* --stabs */
static int dump_ctf_section_info;       /* --ctf */
static char *dump_ctf_section_name;
static char *dump_ctf_parent_name;      /* --ctf-parent */
static int do_demangle;                 /* -C, --demangle */
static bool disassemble;                /* -d */
static bool disassemble_all;            /* -D */
static int disassemble_zeroes;          /* --disassemble-zeroes */
static bool formats_info;               /* -i */
static int wide_output;                 /* -w */
static int insn_width;                  /* --insn-width */
static bfd_vma start_address = (bfd_vma) -1; /* --start-address */
static bfd_vma stop_address = (bfd_vma) -1;  /* --stop-address */
static int dump_debugging;              /* --debugging */
static int dump_debugging_tags;         /* --debugging-tags */
static int suppress_bfd_header;
static int dump_special_syms = 0;       /* --special-syms */
static bfd_vma adjust_section_vma = 0;  /* --adjust-vma */
static int file_start_context = 0;      /* --file-start-context */
static bool display_file_offsets;       /* -F */
static const char *prefix;              /* --prefix */
static int prefix_strip;                /* --prefix-strip */
static size_t prefix_length;
static bool unwind_inlines;             /* --inlines.  */
static const char * disasm_sym;         /* Disassembly start symbol.  */
static const char * source_comment;     /* --source_comment.  */
static bool visualize_jumps = false;    /* --visualize-jumps.  */
static bool color_output = false;       /* --visualize-jumps=color.  */
static bool extended_color_output = false; /* --visualize-jumps=extended-color.  */
static int process_links = false;       /* --process-links.  */

static int dump_any_debugging;
static int demangle_flags = DMGL_ANSI | DMGL_PARAMS;

/* A structure to record the sections mentioned in -j switches.  */
struct only
{
  const char *name; /* The name of the section.  */
  bool seen; /* A flag to indicate that the section has been found in one or more input files.  */
  struct only *next; /* Pointer to the next structure in the list.  */
};
/* Pointer to an array of 'only' structures.
   This pointer is NULL if the -j switch has not been used.  */
static struct only * only_list = NULL;

/* Variables for handling include file path table.  */
static const char **include_paths;
static int include_path_count;

/* Extra info to pass to the section disassembler and address printing
   function.  */
struct objdump_disasm_info
{
  bfd *abfd;
  bool require_sec;
  disassembler_ftype disassemble_fn;
  arelent *reloc;
  const char *symbol;
};

/* Architecture to disassemble for, or default if NULL.  */
static char *machine = NULL;

/* Target specific options to the disassembler.  */
static char *disassembler_options = NULL;

/* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN.  */
static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;

/* The symbol table.  */
static asymbol **syms;

/* Number of symbols in `syms'.  */
static long symcount = 0;

/* The sorted symbol table.  */
static asymbol **sorted_syms;

/* Number of symbols in `sorted_syms'.  */
static long sorted_symcount = 0;

/* The dynamic symbol table.  */
static asymbol **dynsyms;

/* The synthetic symbol table.  */
static asymbol *synthsyms;
static long synthcount = 0;

/* Number of symbols in `dynsyms'.  */
static long dynsymcount = 0;

static bfd_byte *stabs;
static bfd_size_type stab_size;

static bfd_byte *strtab;
static bfd_size_type stabstr_size;

/* Handlers for -P/--private.  */
static const struct objdump_private_desc * const objdump_private_vectors[] =
  {
    OBJDUMP_PRIVATE_VECTORS
    NULL
  };

/* The list of detected jumps inside a function.  */
static struct jump_info *detected_jumps = NULL;

typedef enum unicode_display_type
{
  unicode_default = 0,
  unicode_locale,
  unicode_escape,
  unicode_hex,
  unicode_highlight,
  unicode_invalid
} unicode_display_type;

static unicode_display_type unicode_display = unicode_default;
\f
static void usage (FILE *, int) ATTRIBUTE_NORETURN;
static void
usage (FILE *stream, int status)
{
  fprintf (stream, _("Usage: %s <option(s)> <file(s)>\n"), program_name);
  fprintf (stream, _(" Display information from object <file(s)>.\n"));
  fprintf (stream, _(" At least one of the following switches must be given:\n"));
  fprintf (stream, _("\
  -a, --archive-headers    Display archive header information\n"));
  fprintf (stream, _("\
  -f, --file-headers       Display the contents of the overall file header\n"));
  fprintf (stream, _("\
  -p, --private-headers    Display object format specific file header contents\n"));
  fprintf (stream, _("\
  -P, --private=OPT,OPT... Display object format specific contents\n"));
  fprintf (stream, _("\
  -h, --[section-]headers  Display the contents of the section headers\n"));
  fprintf (stream, _("\
  -x, --all-headers        Display the contents of all headers\n"));
  fprintf (stream, _("\
  -d, --disassemble        Display assembler contents of executable sections\n"));
  fprintf (stream, _("\
  -D, --disassemble-all    Display assembler contents of all sections\n"));
  fprintf (stream, _("\
      --disassemble=<sym>  Display assembler contents from <sym>\n"));
  fprintf (stream, _("\
  -S, --source             Intermix source code with disassembly\n"));
  fprintf (stream, _("\
      --source-comment[=<txt>] Prefix lines of source code with <txt>\n"));
  fprintf (stream, _("\
  -s, --full-contents      Display the full contents of all sections requested\n"));
  fprintf (stream, _("\
  -g, --debugging          Display debug information in object file\n"));
  fprintf (stream, _("\
  -e, --debugging-tags     Display debug information using ctags style\n"));
  fprintf (stream, _("\
  -G, --stabs              Display (in raw form) any STABS info in the file\n"));
  fprintf (stream, _("\
  -W, --dwarf[a/=abbrev, A/=addr, r/=aranges, c/=cu_index, L/=decodedline,\n\
              f/=frames, F/=frames-interp, g/=gdb_index, i/=info, o/=loc,\n\
              m/=macro, p/=pubnames, t/=pubtypes, R/=Ranges, l/=rawline,\n\
              s/=str, O/=str-offsets, u/=trace_abbrev, T/=trace_aranges,\n\
              U/=trace_info]\n\
                           Display the contents of DWARF debug sections\n"));
  fprintf (stream, _("\
  -Wk,--dwarf=links        Display the contents of sections that link to\n\
                            separate debuginfo files\n"));
#if DEFAULT_FOR_FOLLOW_LINKS
  fprintf (stream, _("\
  -WK,--dwarf=follow-links\n\
                           Follow links to separate debug info files (default)\n"));
  fprintf (stream, _("\
  -WN,--dwarf=no-follow-links\n\
                           Do not follow links to separate debug info files\n"));
#else
  fprintf (stream, _("\
  -WK,--dwarf=follow-links\n\
                           Follow links to separate debug info files\n"));
  fprintf (stream, _("\
  -WN,--dwarf=no-follow-links\n\
                           Do not follow links to separate debug info files\n\
                            (default)\n"));
#endif
#if HAVE_LIBDEBUGINFOD
  fprintf (stream, _("\
  -WD --dwarf=use-debuginfod\n\
                           When following links, also query debuginfod servers (default)\n"));
  fprintf (stream, _("\
  -WE --dwarf=do-not-use-debuginfod\n\
                           When following links, do not query debuginfod servers\n"));
#endif
  fprintf (stream, _("\
  -L, --process-links      Display the contents of non-debug sections in\n\
                            separate debuginfo files.  (Implies -WK)\n"));
#ifdef ENABLE_LIBCTF
  fprintf (stream, _("\
      --ctf[=SECTION]      Display CTF info from SECTION, (default `.ctf')\n"));
#endif
  fprintf (stream, _("\
  -t, --syms               Display the contents of the symbol table(s)\n"));
  fprintf (stream, _("\
  -T, --dynamic-syms       Display the contents of the dynamic symbol table\n"));
  fprintf (stream, _("\
  -r, --reloc              Display the relocation entries in the file\n"));
  fprintf (stream, _("\
  -R, --dynamic-reloc      Display the dynamic relocation entries in the file\n"));
  fprintf (stream, _("\
  @<file>                  Read options from <file>\n"));
  fprintf (stream, _("\
  -v, --version            Display this program's version number\n"));
  fprintf (stream, _("\
  -i, --info               List object formats and architectures supported\n"));
  fprintf (stream, _("\
  -H, --help               Display this information\n"));

  if (status != 2)
    {
      const struct objdump_private_desc * const *desc;

      fprintf (stream, _("\n The following switches are optional:\n"));
      fprintf (stream, _("\
  -b, --target=BFDNAME           Specify the target object format as BFDNAME\n"));
      fprintf (stream, _("\
  -m, --architecture=MACHINE     Specify the target architecture as MACHINE\n"));
      fprintf (stream, _("\
  -j, --section=NAME             Only display information for section NAME\n"));
      fprintf (stream, _("\
  -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n"));
      fprintf (stream, _("\
  -EB --endian=big               Assume big endian format when disassembling\n"));
      fprintf (stream, _("\
  -EL --endian=little            Assume little endian format when disassembling\n"));
      fprintf (stream, _("\
      --file-start-context       Include context from start of file (with -S)\n"));
      fprintf (stream, _("\
  -I, --include=DIR              Add DIR to search list for source files\n"));
      fprintf (stream, _("\
  -l, --line-numbers             Include line numbers and filenames in output\n"));
      fprintf (stream, _("\
  -F, --file-offsets             Include file offsets when displaying information\n"));
      fprintf (stream, _("\
  -C, --demangle[=STYLE]         Decode mangled/processed symbol names\n"));
      display_demangler_styles (stream, _("\
                                   STYLE can be "));
      fprintf (stream, _("\
      --recurse-limit            Enable a limit on recursion whilst demangling\n\
                                  (default)\n"));
      fprintf (stream, _("\
      --no-recurse-limit         Disable a limit on recursion whilst demangling\n"));
      fprintf (stream, _("\
  -w, --wide                     Format output for more than 80 columns\n"));
      fprintf (stream, _("\
  -U[d|l|i|x|e|h]                Controls the display of UTF-8 unicode characters\n\
  --unicode=[default|locale|invalid|hex|escape|highlight]\n"));
      fprintf (stream, _("\
  -z, --disassemble-zeroes       Do not skip blocks of zeroes when disassembling\n"));
      fprintf (stream, _("\
      --start-address=ADDR       Only process data whose address is >= ADDR\n"));
      fprintf (stream, _("\
      --stop-address=ADDR        Only process data whose address is < ADDR\n"));
      fprintf (stream, _("\
      --no-addresses             Do not print address alongside disassembly\n"));
      fprintf (stream, _("\
      --prefix-addresses         Print complete address alongside disassembly\n"));
      fprintf (stream, _("\
      --[no-]show-raw-insn       Display hex alongside symbolic disassembly\n"));
      fprintf (stream, _("\
      --insn-width=WIDTH         Display WIDTH bytes on a single line for -d\n"));
      fprintf (stream, _("\
      --adjust-vma=OFFSET        Add OFFSET to all displayed section addresses\n"));
      fprintf (stream, _("\
      --special-syms             Include special symbols in symbol dumps\n"));
      fprintf (stream, _("\
      --inlines                  Print all inlines for source line (with -l)\n"));
      fprintf (stream, _("\
      --prefix=PREFIX            Add PREFIX to absolute paths for -S\n"));
      fprintf (stream, _("\
      --prefix-strip=LEVEL       Strip initial directory names for -S\n"));
      fprintf (stream, _("\
      --dwarf-depth=N            Do not display DIEs at depth N or greater\n"));
      fprintf (stream, _("\
      --dwarf-start=N            Display DIEs starting at offset N\n"));
      fprintf (stream, _("\
      --dwarf-check              Make additional dwarf consistency checks.\n"));
#ifdef ENABLE_LIBCTF
      fprintf (stream, _("\
      --ctf-parent=NAME          Use CTF archive member NAME as the CTF parent\n"));
#endif
      fprintf (stream, _("\
      --visualize-jumps          Visualize jumps by drawing ASCII art lines\n"));
      fprintf (stream, _("\
      --visualize-jumps=color    Use colors in the ASCII art\n"));
      fprintf (stream, _("\
      --visualize-jumps=extended-color\n\
                                 Use extended 8-bit color codes\n"));
      fprintf (stream, _("\
      --visualize-jumps=off      Disable jump visualization\n\n"));

      list_supported_targets (program_name, stream);
      list_supported_architectures (program_name, stream);

      disassembler_usage (stream);

      if (objdump_private_vectors[0] != NULL)
        {
          fprintf (stream,
                   _("\nOptions supported for -P/--private switch:\n"));
          for (desc = objdump_private_vectors; *desc != NULL; desc++)
            (*desc)->help (stream);
        }
    }
  if (REPORT_BUGS_TO[0] && status == 0)
    fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
  exit (status);
}

/* 150 isn't special; it's just an arbitrary non-ASCII char value.  */
enum option_values
  {
    OPTION_ENDIAN=150,
    OPTION_START_ADDRESS,
    OPTION_STOP_ADDRESS,
    OPTION_DWARF,
    OPTION_PREFIX,
    OPTION_PREFIX_STRIP,
    OPTION_INSN_WIDTH,
    OPTION_ADJUST_VMA,
    OPTION_DWARF_DEPTH,
    OPTION_DWARF_CHECK,
    OPTION_DWARF_START,
    OPTION_RECURSE_LIMIT,
    OPTION_NO_RECURSE_LIMIT,
    OPTION_INLINES,
    OPTION_SOURCE_COMMENT,
#ifdef ENABLE_LIBCTF
    OPTION_CTF,
    OPTION_CTF_PARENT,
#endif
    OPTION_VISUALIZE_JUMPS
  };

static struct option long_options[]=
{
  {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
  {"all-headers", no_argument, NULL, 'x'},
  {"architecture", required_argument, NULL, 'm'},
  {"archive-headers", no_argument, NULL, 'a'},
#ifdef ENABLE_LIBCTF
  {"ctf", optional_argument, NULL, OPTION_CTF},
  {"ctf-parent", required_argument, NULL, OPTION_CTF_PARENT},
#endif
  {"debugging", no_argument, NULL, 'g'},
  {"debugging-tags", no_argument, NULL, 'e'},
  {"demangle", optional_argument, NULL, 'C'},
  {"disassemble", optional_argument, NULL, 'd'},
  {"disassemble-all", no_argument, NULL, 'D'},
  {"disassemble-zeroes", no_argument, NULL, 'z'},
  {"disassembler-options", required_argument, NULL, 'M'},
  {"dwarf", optional_argument, NULL, OPTION_DWARF},
  {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
  {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
  {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
  {"dynamic-reloc", no_argument, NULL, 'R'},
  {"dynamic-syms", no_argument, NULL, 'T'},
  {"endian", required_argument, NULL, OPTION_ENDIAN},
  {"file-headers", no_argument, NULL, 'f'},
  {"file-offsets", no_argument, NULL, 'F'},
  {"file-start-context", no_argument, &file_start_context, 1},
  {"full-contents", no_argument, NULL, 's'},
  {"headers", no_argument, NULL, 'h'},
  {"help", no_argument, NULL, 'H'},
  {"include", required_argument, NULL, 'I'},
  {"info", no_argument, NULL, 'i'},
  {"inlines", no_argument, 0, OPTION_INLINES},
  {"insn-width", required_argument, NULL, OPTION_INSN_WIDTH},
  {"line-numbers", no_argument, NULL, 'l'},
  {"no-addresses", no_argument, &no_addresses, 1},
  {"no-recurse-limit", no_argument, NULL, OPTION_NO_RECURSE_LIMIT},
  {"no-recursion-limit", no_argument, NULL, OPTION_NO_RECURSE_LIMIT},
  {"no-show-raw-insn", no_argument, &show_raw_insn, -1},
  {"prefix", required_argument, NULL, OPTION_PREFIX},
  {"prefix-addresses", no_argument, &prefix_addresses, 1},
  {"prefix-strip", required_argument, NULL, OPTION_PREFIX_STRIP},
  {"private", required_argument, NULL, 'P'},
  {"private-headers", no_argument, NULL, 'p'},
  {"process-links", no_argument, &process_links, true},
  {"recurse-limit", no_argument, NULL, OPTION_RECURSE_LIMIT},
  {"recursion-limit", no_argument, NULL, OPTION_RECURSE_LIMIT},
  {"reloc", no_argument, NULL, 'r'},
  {"section", required_argument, NULL, 'j'},
  {"section-headers", no_argument, NULL, 'h'},
  {"show-raw-insn", no_argument, &show_raw_insn, 1},
  {"source", no_argument, NULL, 'S'},
  {"source-comment", optional_argument, NULL, OPTION_SOURCE_COMMENT},
  {"special-syms", no_argument, &dump_special_syms, 1},
  {"stabs", no_argument, NULL, 'G'},
  {"start-address", required_argument, NULL, OPTION_START_ADDRESS},
  {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
  {"syms", no_argument, NULL, 't'},
  {"target", required_argument, NULL, 'b'},
  {"unicode", required_argument, NULL, 'U'},
  {"version", no_argument, NULL, 'V'},
  {"visualize-jumps", optional_argument, 0, OPTION_VISUALIZE_JUMPS},
  {"wide", no_argument, NULL, 'w'},
  {NULL, no_argument, NULL, 0}
};
\f
static void
nonfatal (const char *msg)
{
  bfd_nonfatal (msg);
  exit_status = 1;
}

/* Convert a potential UTF-8 encoded sequence in IN into characters in OUT.
   The conversion format is controlled by the unicode_display variable.
   Returns the number of characters added to OUT.
   Returns the number of bytes consumed from IN in CONSUMED.
   Always consumes at least one byte and displays at least one character.  */

static unsigned int
display_utf8 (const unsigned char * in, char * out, unsigned int * consumed)
{
  char *        orig_out = out;
  unsigned int  nchars = 0;
  unsigned int j;

  if (unicode_display == unicode_default)
    goto invalid;

  if (in[0] < 0xc0)
    goto invalid;

  if ((in[1] & 0xc0) != 0x80)
    goto invalid;

  if ((in[0] & 0x20) == 0)
    {
      nchars = 2;
      goto valid;
    }

  if ((in[2] & 0xc0) != 0x80)
    goto invalid;

  if ((in[0] & 0x10) == 0)
    {
      nchars = 3;
      goto valid;
    }

  if ((in[3] & 0xc0) != 0x80)
    goto invalid;

  nchars = 4;

 valid:
  switch (unicode_display)
    {
    case unicode_locale:
      /* Copy the bytes into the output buffer as is.  */
      memcpy (out, in, nchars);
      out += nchars;
      break;

    case unicode_invalid:
    case unicode_hex:
      out += sprintf (out, "%c", unicode_display == unicode_hex ? '<' : '{');
      out += sprintf (out, "0x");
      for (j = 0; j < nchars; j++)
        out += sprintf (out, "%02x", in [j]);
      out += sprintf (out, "%c", unicode_display == unicode_hex ? '>' : '}');
      break;

    case unicode_highlight:
      if (isatty (1))
        out += sprintf (out, "\x1B[31;47m"); /* Red.  */
      /* Fall through.  */
    case unicode_escape:
      switch (nchars)
        {
        case 2:
          out += sprintf (out, "\\u%02x%02x",
                  ((in[0] & 0x1c) >> 2),
                  ((in[0] & 0x03) << 6) | (in[1] & 0x3f));
          break;

        case 3:
          out += sprintf (out, "\\u%02x%02x",
                  ((in[0] & 0x0f) << 4) | ((in[1] & 0x3c) >> 2),
                  ((in[1] & 0x03) << 6) | ((in[2] & 0x3f)));
          break;

        case 4:
          out += sprintf (out, "\\u%02x%02x%02x",
                  ((in[0] & 0x07) << 6) | ((in[1] & 0x3c) >> 2),
                  ((in[1] & 0x03) << 6) | ((in[2] & 0x3c) >> 2),
                  ((in[2] & 0x03) << 6) | ((in[3] & 0x3f)));
          break;
        default:
          /* URG.  */
          break;
        }

      if (unicode_display == unicode_highlight && isatty (1))
        out += sprintf (out, "\033[0m"); /* Default colour.  */
      break;

    default:
      /* URG */
      break;
    }

  * consumed = nchars;
  return out - orig_out;

 invalid:
  /* Not a valid UTF-8 sequence.  */
  *out = *in;
  * consumed = 1;
  return 1;
}

/* Returns a version of IN with any control characters
   replaced by escape sequences.  Uses a static buffer
   if necessary.

   If unicode display is enabled, then also handles the
   conversion of unicode characters.  */

static const char *
sanitize_string (const char * in)
{
  static char *  buffer = NULL;
  static size_t  buffer_len = 0;
  const char *   original = in;
  char *         out;

  /* Paranoia.  */
  if (in == NULL)
    return "";

  /* See if any conversion is necessary.  In the majority
     of cases it will not be needed.  */
  do
    {
      unsigned char c = *in++;

      if (c == 0)
        return original;

      if (ISCNTRL (c))
        break;

      if (unicode_display != unicode_default && c >= 0xc0)
        break;
    }
  while (1);

  /* Copy the input, translating as needed.  */
  in = original;
  if (buffer_len < (strlen (in) * 9))
    {
      free ((void *) buffer);
      buffer_len = strlen (in) * 9;
      buffer = xmalloc (buffer_len + 1);
    }

  out = buffer;
  do
    {
      unsigned char c = *in++;

      if (c == 0)
        break;

      if (ISCNTRL (c))
        {
          *out++ = '^';
          *out++ = c + 0x40;
        }
      else if (unicode_display != unicode_default && c >= 0xc0)
        {
          unsigned int num_consumed;

          out += display_utf8 ((const unsigned char *)(in - 1), out, & num_consumed);
          in += num_consumed - 1;
        }
      else
        *out++ = c;
    }
  while (1);

  *out = 0;
  return buffer;
}

\f
/* Returns TRUE if the specified section should be dumped.  */

static bool
process_section_p (asection * section)
{
  struct only * only;

  if (only_list == NULL)
    return true;

  for (only = only_list; only; only = only->next)
    if (strcmp (only->name, section->name) == 0)
      {
        only->seen = true;
        return true;
      }

  return false;
}

/* Add an entry to the 'only' list.  */

static void
add_only (char * name)
{
  struct only * only;

  /* First check to make sure that we do not
     already have an entry for this name.  */
  for (only = only_list; only; only = only->next)
    if (strcmp (only->name, name) == 0)
      return;

  only = xmalloc (sizeof * only);
  only->name = name;
  only->seen = false;
  only->next = only_list;
  only_list = only;
}

/* Release the memory used by the 'only' list.
   PR 11225: Issue a warning message for unseen sections.
   Only do this if none of the sections were seen.  This is mainly to support
   tools like the GAS testsuite where an object file is dumped with a list of
   generic section names known to be present in a range of different file
   formats.  */

static void
free_only_list (void)
{
  bool at_least_one_seen = false;
  struct only * only;
  struct only * next;

  if (only_list == NULL)
    return;

  for (only = only_list; only; only = only->next)
    if (only->seen)
      {
        at_least_one_seen = true;
        break;
      }

  for (only = only_list; only; only = next)
    {
      if (! at_least_one_seen)
        {
          non_fatal (_("section '%s' mentioned in a -j option, "
                       "but not found in any input file"),
                     only->name);
          exit_status = 1;
        }
      next = only->next;
      free (only);
    }
}

\f
static void
dump_section_header (bfd *abfd, asection *section, void *data)
{
  char *comma = "";
  unsigned int opb = bfd_octets_per_byte (abfd, section);
  int longest_section_name = *((int *) data);

  /* Ignore linker created section.  See elfNN_ia64_object_p in
     bfd/elfxx-ia64.c.  */
  if (section->flags & SEC_LINKER_CREATED)
    return;

  /* PR 10413: Skip sections that we are ignoring.  */
  if (! process_section_p (section))
    return;

  printf ("%3d %-*s %08lx  ", section->index, longest_section_name,
          sanitize_string (bfd_section_name (section)),
          (unsigned long) bfd_section_size (section) / opb);
  bfd_printf_vma (abfd, bfd_section_vma (section));
  printf ("  ");
  bfd_printf_vma (abfd, section->lma);
  printf ("  %08lx  2**%u", (unsigned long) section->filepos,
          bfd_section_alignment (section));
  if (! wide_output)
    printf ("\n                ");
  printf ("  ");

#define PF(x, y) \
  if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }

  PF (SEC_HAS_CONTENTS, "CONTENTS");
  PF (SEC_ALLOC, "ALLOC");
  PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
  PF (SEC_LOAD, "LOAD");
  PF (SEC_RELOC, "RELOC");
  PF (SEC_READONLY, "READONLY");
  PF (SEC_CODE, "CODE");
  PF (SEC_DATA, "DATA");
  PF (SEC_ROM, "ROM");
  PF (SEC_DEBUGGING, "DEBUGGING");
  PF (SEC_NEVER_LOAD, "NEVER_LOAD");
  PF (SEC_EXCLUDE, "EXCLUDE");
  PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
  if (bfd_get_arch (abfd) == bfd_arch_tic54x)
    {
      PF (SEC_TIC54X_BLOCK, "BLOCK");
      PF (SEC_TIC54X_CLINK, "CLINK");
    }
  PF (SEC_SMALL_DATA, "SMALL_DATA");
  if (bfd_get_flavour (abfd) == bfd_target_coff_flavour)
    {
      PF (SEC_COFF_SHARED, "SHARED");
      PF (SEC_COFF_NOREAD, "NOREAD");
    }
  else if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
    {
      PF (SEC_ELF_OCTETS, "OCTETS");
      PF (SEC_ELF_PURECODE, "PURECODE");
    }
  PF (SEC_THREAD_LOCAL, "THREAD_LOCAL");
  PF (SEC_GROUP, "GROUP");
  if (bfd_get_arch (abfd) == bfd_arch_mep)
    {
      PF (SEC_MEP_VLIW, "VLIW");
    }

  if ((section->flags & SEC_LINK_ONCE) != 0)
    {
      const char *ls;
      struct coff_comdat_info *comdat;

      switch (section->flags & SEC_LINK_DUPLICATES)
        {
        default:
          abort ();
        case SEC_LINK_DUPLICATES_DISCARD:
          ls = "LINK_ONCE_DISCARD";
          break;
        case SEC_LINK_DUPLICATES_ONE_ONLY:
          ls = "LINK_ONCE_ONE_ONLY";
          break;
        case SEC_LINK_DUPLICATES_SAME_SIZE:
          ls = "LINK_ONCE_SAME_SIZE";
          break;
        case SEC_LINK_DUPLICATES_SAME_CONTENTS:
          ls = "LINK_ONCE_SAME_CONTENTS";
          break;
        }
      printf ("%s%s", comma, ls);

      comdat = bfd_coff_get_comdat_section (abfd, section);
      if (comdat != NULL)
        printf (" (COMDAT %s %ld)", comdat->name, comdat->symbol);

      comma = ", ";
    }

  printf ("\n");
#undef PF
}

/* Called on each SECTION in ABFD, update the int variable pointed to by
   DATA which contains the string length of the longest section name.  */

static void
find_longest_section_name (bfd *abfd ATTRIBUTE_UNUSED,
                           asection *section, void *data)
{
  int *longest_so_far = (int *) data;
  const char *name;
  int len;

  /* Ignore linker created section.  */
  if (section->flags & SEC_LINKER_CREATED)
    return;

  /* Skip sections that we are ignoring.  */
  if (! process_section_p (section))
    return;

  name = bfd_section_name (section);
  len = (int) strlen (name);
  if (len > *longest_so_far)
    *longest_so_far = len;
}

static void
dump_headers (bfd *abfd)
{
  /* The default width of 13 is just an arbitrary choice.  */
  int max_section_name_length = 13;
  int bfd_vma_width;

#ifndef BFD64
  bfd_vma_width = 10;
#else
  /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses.  */
  if (bfd_get_arch_size (abfd) == 32)
    bfd_vma_width = 10;
  else
    bfd_vma_width = 18;
#endif

  printf (_("Sections:\n"));

  if (wide_output)
    bfd_map_over_sections (abfd, find_longest_section_name,
                           &max_section_name_length);

  printf (_("Idx %-*s Size      %-*s%-*sFile off  Algn"),
          max_section_name_length, "Name",
          bfd_vma_width, "VMA",
          bfd_vma_width, "LMA");

  if (wide_output)
    printf (_("  Flags"));
  printf ("\n");

  bfd_map_over_sections (abfd, dump_section_header,
                         &max_section_name_length);
}
\f
static asymbol **
slurp_symtab (bfd *abfd)
{
  asymbol **sy = NULL;
  long storage;

  if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
    {
      symcount = 0;
      return NULL;
    }

  storage = bfd_get_symtab_upper_bound (abfd);
  if (storage < 0)
    {
      non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd));
      bfd_fatal (_("error message was"));
    }

  if (storage)
    {
      off_t filesize = bfd_get_file_size (abfd);

      /* qv PR 24707.  */
      if (filesize > 0
          && filesize < storage
          /* The MMO file format supports its own special compression
             technique, so its sections can be larger than the file size.  */
          && bfd_get_flavour (abfd) != bfd_target_mmo_flavour)
        {
          bfd_nonfatal_message (bfd_get_filename (abfd), abfd, NULL,
                                _("error: symbol table size (%#lx) "
                                  "is larger than filesize (%#lx)"),
                                storage, (long) filesize);
          exit_status = 1;
          symcount = 0;
          return NULL;
        }

      sy = (asymbol **) xmalloc (storage);
    }

  symcount = bfd_canonicalize_symtab (abfd, sy);
  if (symcount < 0)
    bfd_fatal (bfd_get_filename (abfd));
  return sy;
}

/* Read in the dynamic symbols.  */

static asymbol **
slurp_dynamic_symtab (bfd *abfd)
{
  asymbol **sy = NULL;
  long storage;

  storage = bfd_get_dynamic_symtab_upper_bound (abfd);
  if (storage < 0)
    {
      if (!(bfd_get_file_flags (abfd) & DYNAMIC))
        {
          non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));
          exit_status = 1;
          dynsymcount = 0;
          return NULL;
        }

      bfd_fatal (bfd_get_filename (abfd));
    }

  if (storage)
    sy = (asymbol **) xmalloc (storage);

  dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
  if (dynsymcount < 0)
    bfd_fatal (bfd_get_filename (abfd));
  return sy;
}

/* Some symbol names are significant and should be kept in the
   table of sorted symbol names, even if they are marked as
   debugging/section symbols.  */

static bool
is_significant_symbol_name (const char * name)
{
  return startswith (name, ".plt") || startswith (name, ".got");
}

/* Filter out (in place) symbols that are useless for disassembly.
   COUNT is the number of elements in SYMBOLS.
   Return the number of useful symbols.  */

static long
remove_useless_symbols (asymbol **symbols, long count)
{
  asymbol **in_ptr = symbols, **out_ptr = symbols;

  while (--count >= 0)
    {
      asymbol *sym = *in_ptr++;

      if (sym->name == NULL || sym->name[0] == '\0')
        continue;
      if ((sym->flags & (BSF_DEBUGGING | BSF_SECTION_SYM))
          && ! is_significant_symbol_name (sym->name))
        continue;
      if (bfd_is_und_section (sym->section)
          || bfd_is_com_section (sym->section))
        continue;

      *out_ptr++ = sym;
    }
  return out_ptr - symbols;
}

static const asection *compare_section;

/* Sort symbols into value order.  */

static int
compare_symbols (const void *ap, const void *bp)
{
  const asymbol *a = * (const asymbol **) ap;
  const asymbol *b = * (const asymbol **) bp;
  const char *an;
  const char *bn;
  size_t anl;
  size_t bnl;
  bool as, af, bs, bf;
  flagword aflags;
  flagword bflags;

  if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
    return 1;
  else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
    return -1;

  /* Prefer symbols from the section currently being disassembled.
     Don't sort symbols from other sections by section, since there
     isn't much reason to prefer one section over another otherwise.
     See sym_ok comment for why we compare by section name.  */
  as = strcmp (compare_section->name, a->section->name) == 0;
  bs = strcmp (compare_section->name, b->section->name) == 0;
  if (as && !bs)
    return -1;
  if (!as && bs)
    return 1;

  an = bfd_asymbol_name (a);
  bn = bfd_asymbol_name (b);
  anl = strlen (an);
  bnl = strlen (bn);

  /* The symbols gnu_compiled and gcc2_compiled convey no real
     information, so put them after other symbols with the same value.  */
  af = (strstr (an, "gnu_compiled") != NULL
        || strstr (an, "gcc2_compiled") != NULL);
  bf = (strstr (bn, "gnu_compiled") != NULL
        || strstr (bn, "gcc2_compiled") != NULL);

  if (af && ! bf)
    return 1;
  if (! af && bf)
    return -1;

  /* We use a heuristic for the file name, to try to sort it after
     more useful symbols.  It may not work on non Unix systems, but it
     doesn't really matter; the only difference is precisely which
     symbol names get printed.  */

#define file_symbol(s, sn, snl)                 \
  (((s)->flags & BSF_FILE) != 0                 \
   || ((snl) > 2                                \
       && (sn)[(snl) - 2] == '.'                \
       && ((sn)[(snl) - 1] == 'o'               \
           || (sn)[(snl) - 1] == 'a')))

  af = file_symbol (a, an, anl);
  bf = file_symbol (b, bn, bnl);

  if (af && ! bf)
    return 1;
  if (! af && bf)
    return -1;

  /* Sort function and object symbols before global symbols before
     local symbols before section symbols before debugging symbols.  */

  aflags = a->flags;
  bflags = b->flags;

  if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
    {
      if ((aflags & BSF_DEBUGGING) != 0)
        return 1;
      else
        return -1;
    }
  if ((aflags & BSF_SECTION_SYM) != (bflags & BSF_SECTION_SYM))
    {
      if ((aflags & BSF_SECTION_SYM) != 0)
        return 1;
      else
        return -1;
    }
  if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
    {
      if ((aflags & BSF_FUNCTION) != 0)
        return -1;
      else
        return 1;
    }
  if ((aflags & BSF_OBJECT) != (bflags & BSF_OBJECT))
    {
      if ((aflags & BSF_OBJECT) != 0)
        return -1;
      else
        return 1;
    }
  if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
    {
      if ((aflags & BSF_LOCAL) != 0)
        return 1;
      else
        return -1;
    }
  if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
    {
      if ((aflags & BSF_GLOBAL) != 0)
        return -1;
      else
        return 1;
    }

  if (bfd_get_flavour (bfd_asymbol_bfd (a)) == bfd_target_elf_flavour
      && bfd_get_flavour (bfd_asymbol_bfd (b)) == bfd_target_elf_flavour)
    {
      bfd_vma asz, bsz;

      asz = 0;
      if ((a->flags & (BSF_SECTION_SYM | BSF_SYNTHETIC)) == 0)
        asz = ((elf_symbol_type *) a)->internal_elf_sym.st_size;
      bsz = 0;
      if ((b->flags & (BSF_SECTION_SYM | BSF_SYNTHETIC)) == 0)
        bsz = ((elf_symbol_type *) b)->internal_elf_sym.st_size;
      if (asz != bsz)
        return asz > bsz ? -1 : 1;
    }

  /* Symbols that start with '.' might be section names, so sort them
     after symbols that don't start with '.'.  */
  if (an[0] == '.' && bn[0] != '.')
    return 1;
  if (an[0] != '.' && bn[0] == '.')
    return -1;

  /* Finally, if we can't distinguish them in any other way, try to
     get consistent results by sorting the symbols by name.  */
  return strcmp (an, bn);
}

/* Sort relocs into address order.  */

static int
compare_relocs (const void *ap, const void *bp)
{
  const arelent *a = * (const arelent **) ap;
  const arelent *b = * (const arelent **) bp;

  if (a->address > b->address)
    return 1;
  else if (a->address < b->address)
    return -1;

  /* So that associated relocations tied to the same address show up
     in the correct order, we don't do any further sorting.  */
  if (a > b)
    return 1;
  else if (a < b)
    return -1;
  else
    return 0;
}

/* Print an address (VMA) to the output stream in INFO.
   If SKIP_ZEROES is TRUE, omit leading zeroes.  */

static void
objdump_print_value (bfd_vma vma, struct disassemble_info *inf,
                     bool skip_zeroes)
{
  char buf[30];
  char *p;
  struct objdump_disasm_info *aux;

  aux = (struct objdump_disasm_info *) inf->application_data;
  bfd_sprintf_vma (aux->abfd, buf, vma);
  if (! skip_zeroes)
    p = buf;
  else
    {
      for (p = buf; *p == '0'; ++p)
        ;
      if (*p == '\0')
        --p;
    }
  (*inf->fprintf_func) (inf->stream, "%s", p);
}

/* Print the name of a symbol.  */

static void
objdump_print_symname (bfd *abfd, struct disassemble_info *inf,
                       asymbol *sym)
{
  char *alloc;
  const char *name, *version_string = NULL;
  bool hidden = false;

  alloc = NULL;
  name = bfd_asymbol_name (sym);
  if (do_demangle && name[0] != '\0')
    {
      /* Demangle the name.  */
      alloc = bfd_demangle (abfd, name, demangle_flags);
      if (alloc != NULL)
        name = alloc;
    }

  if ((sym->flags & (BSF_SECTION_SYM | BSF_SYNTHETIC)) == 0)
    version_string = bfd_get_symbol_version_string (abfd, sym, true,
                                                    &hidden);

  if (bfd_is_und_section (bfd_asymbol_section (sym)))
    hidden = true;

  name = sanitize_string (name);

  if (inf != NULL)
    {
      (*inf->fprintf_func) (inf->stream, "%s", name);
      if (version_string && *version_string != '\0')
        (*inf->fprintf_func) (inf->stream, hidden ? "@%s" : "@@%s",
                              version_string);
    }
  else
    {
      printf ("%s", name);
      if (version_string && *version_string != '\0')
        printf (hidden ? "@%s" : "@@%s", version_string);
    }

  if (alloc != NULL)
    free (alloc);
}

static inline bool
sym_ok (bool want_section,
        bfd *abfd ATTRIBUTE_UNUSED,
        long place,
        asection *sec,
        struct disassemble_info *inf)
{
  if (want_section)
    {
      /* NB: An object file can have different sections with the same
         section name.  Compare compare section pointers if they have
         the same owner.  */
      if (sorted_syms[place]->section->owner == sec->owner
          && sorted_syms[place]->section != sec)
        return false;

      /* Note - we cannot just compare section pointers because they could
         be different, but the same...  Ie the symbol that we are trying to
         find could have come from a separate debug info file.  Under such
         circumstances the symbol will be associated with a section in the
         debug info file, whilst the section we want is in a normal file.
         So the section pointers will be different, but the section names
         will be the same.  */
      if (strcmp (bfd_section_name (sorted_syms[place]->section),
                  bfd_section_name (sec)) != 0)
        return false;
    }

  return inf->symbol_is_valid (sorted_syms[place], inf);
}

/* Locate a symbol given a bfd and a section (from INFO->application_data),
   and a VMA.  If INFO->application_data->require_sec is TRUE, then always
   require the symbol to be in the section.  Returns NULL if there is no
   suitable symbol.  If PLACE is not NULL, then *PLACE is set to the index
   of the symbol in sorted_syms.  */

static asymbol *
find_symbol_for_address (bfd_vma vma,
                         struct disassemble_info *inf,
                         long *place)
{
  /* @@ Would it speed things up to cache the last two symbols returned,
     and maybe their address ranges?  For many processors, only one memory
     operand can be present at a time, so the 2-entry cache wouldn't be
     constantly churned by code doing heavy memory accesses.  */

  /* Indices in `sorted_syms'.  */
  long min = 0;
  long max_count = sorted_symcount;
  long thisplace;
  struct objdump_disasm_info *aux;
  bfd *abfd;
  asection *sec;
  unsigned int opb;
  bool want_section;
  long rel_count;

  if (sorted_symcount < 1)
    return NULL;

  aux = (struct objdump_disasm_info *) inf->application_data;
  abfd = aux->abfd;
  sec = inf->section;
  opb = inf->octets_per_byte;

  /* Perform a binary search looking for the closest symbol to the
     required value.  We are searching the range (min, max_count].  */
  while (min + 1 < max_count)
    {
      asymbol *sym;

      thisplace = (max_count + min) / 2;
      sym = sorted_syms[thisplace];

      if (bfd_asymbol_value (sym) > vma)
        max_count = thisplace;
      else if (bfd_asymbol_value (sym) < vma)
        min = thisplace;
      else
        {
          min = thisplace;
          break;
        }
    }

  /* The symbol we want is now in min, the low end of the range we
     were searching.  If there are several symbols with the same
     value, we want the first one.  */
  thisplace = min;
  while (thisplace > 0
         && (bfd_asymbol_value (sorted_syms[thisplace])
             == bfd_asymbol_value (sorted_syms[thisplace - 1])))
    --thisplace;

  /* Prefer a symbol in the current section if we have multple symbols
     with the same value, as can occur with overlays or zero size
     sections.  */
  min = thisplace;
  while (min < max_count
         && (bfd_asymbol_value (sorted_syms[min])
             == bfd_asymbol_value (sorted_syms[thisplace])))
    {
      if (sym_ok (true, abfd, min, sec, inf))
        {
          thisplace = min;

          if (place != NULL)
            *place = thisplace;

          return sorted_syms[thisplace];
        }
      ++min;
    }

  /* If the file is relocatable, and the symbol could be from this
     section, prefer a symbol from this section over symbols from
     others, even if the other symbol's value might be closer.

     Note that this may be wrong for some symbol references if the
     sections have overlapping memory ranges, but in that case there's
     no way to tell what's desired without looking at the relocation
     table.

     Also give the target a chance to reject symbols.  */
  want_section = (aux->require_sec
                  || ((abfd->flags & HAS_RELOC) != 0
                      && vma >= bfd_section_vma (sec)
                      && vma < (bfd_section_vma (sec)
                                + bfd_section_size (sec) / opb)));

  if (! sym_ok (want_section, abfd, thisplace, sec, inf))
    {
      long i;
      long newplace = sorted_symcount;

      for (i = min - 1; i >= 0; i--)
        {
          if (sym_ok (want_section, abfd, i, sec, inf))
            {
              if (newplace == sorted_symcount)
                newplace = i;

              if (bfd_asymbol_value (sorted_syms[i])
                  != bfd_asymbol_value (sorted_syms[newplace]))
                break;

              /* Remember this symbol and keep searching until we reach
                 an earlier address.  */
              newplace = i;
            }
        }

      if (newplace != sorted_symcount)
        thisplace = newplace;
      else
        {
          /* We didn't find a good symbol with a smaller value.
             Look for one with a larger value.  */
          for (i = thisplace + 1; i < sorted_symcount; i++)
            {
              if (sym_ok (want_section, abfd, i, sec, inf))
                {
                  thisplace = i;
                  break;
                }
            }
        }

      if (! sym_ok (want_section, abfd, thisplace, sec, inf))
        /* There is no suitable symbol.  */
        return NULL;
    }

  /* If we have not found an exact match for the specified address
     and we have dynamic relocations available, then we can produce
     a better result by matching a relocation to the address and
     using the symbol associated with that relocation.  */
  rel_count = inf->dynrelcount;
  if (!want_section
      && sorted_syms[thisplace]->value != vma
      && rel_count > 0
      && inf->dynrelbuf != NULL
      && inf->dynrelbuf[0]->address <= vma
      && inf->dynrelbuf[rel_count - 1]->address >= vma
      /* If we have matched a synthetic symbol, then stick with that.  */
      && (sorted_syms[thisplace]->flags & BSF_SYNTHETIC) == 0)
    {
      arelent **  rel_low;
      arelent **  rel_high;

      rel_low = inf->dynrelbuf;
      rel_high = rel_low + rel_count - 1;
      while (rel_low <= rel_high)
        {
          arelent **rel_mid = &rel_low[(rel_high - rel_low) / 2];
          arelent * rel = *rel_mid;

          if (rel->address == vma)
            {
              /* Absolute relocations do not provide a more helpful
                 symbolic address.  Find a non-absolute relocation
                 with the same address.  */
              arelent **rel_vma = rel_mid;
              for (rel_mid--;
                   rel_mid >= rel_low && rel_mid[0]->address == vma;
                   rel_mid--)
                rel_vma = rel_mid;

              for (; rel_vma <= rel_high && rel_vma[0]->address == vma;
                   rel_vma++)
                {
                  rel = *rel_vma;
                  if (rel->sym_ptr_ptr != NULL
                      && ! bfd_is_abs_section ((* rel->sym_ptr_ptr)->section))
                    {
                      if (place != NULL)
                        * place = thisplace;
                      return * rel->sym_ptr_ptr;
                    }
                }
              break;
            }

          if (vma < rel->address)
            rel_high = rel_mid;
          else if (vma >= rel_mid[1]->address)
            rel_low = rel_mid + 1;
          else
            break;
        }
    }

  if (place != NULL)
    *place = thisplace;

  return sorted_syms[thisplace];
}

/* Print an address and the offset to the nearest symbol.  */

static void
objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym,
                             bfd_vma vma, struct disassemble_info *inf,
                             bool skip_zeroes)
{
  if (!no_addresses)
    {
      objdump_print_value (vma, inf, skip_zeroes);
      (*inf->fprintf_func) (inf->stream, " ");
    }

  if (sym == NULL)
    {
      bfd_vma secaddr;

      (*inf->fprintf_func) (inf->stream, "<%s",
                            sanitize_string (bfd_section_name (sec)));
      secaddr = bfd_section_vma (sec);
      if (vma < secaddr)
        {
          (*inf->fprintf_func) (inf->stream, "-0x");
          objdump_print_value (secaddr - vma, inf, true);
        }
      else if (vma > secaddr)
        {
          (*inf->fprintf_func) (inf->stream, "+0x");
          objdump_print_value (vma - secaddr, inf, true);
        }
      (*inf->fprintf_func) (inf->stream, ">");
    }
  else
    {
      (*inf->fprintf_func) (inf->stream, "<");

      objdump_print_symname (abfd, inf, sym);

      if (bfd_asymbol_value (sym) == vma)
        ;
      /* Undefined symbols in an executables and dynamic objects do not have
         a value associated with them, so it does not make sense to display
         an offset relative to them.  Normally we would not be provided with
         this kind of symbol, but the target backend might choose to do so,
         and the code in find_symbol_for_address might return an as yet
         unresolved symbol associated with a dynamic reloc.  */
      else if ((bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
               && bfd_is_und_section (sym->section))
        ;
      else if (bfd_asymbol_value (sym) > vma)
        {
          (*inf->fprintf_func) (inf->stream, "-0x");
          objdump_print_value (bfd_asymbol_value (sym) - vma, inf, true);
        }
      else if (vma > bfd_asymbol_value (sym))
        {
          (*inf->fprintf_func) (inf->stream, "+0x");
          objdump_print_value (vma - bfd_asymbol_value (sym), inf, true);
        }

      (*inf->fprintf_func) (inf->stream, ">");
    }

  if (display_file_offsets)
    inf->fprintf_func (inf->stream, _(" (File Offset: 0x%lx)"),
                        (long int)(sec->filepos + (vma - sec->vma)));
}

/* Print an address (VMA), symbolically if possible.
   If SKIP_ZEROES is TRUE, don't output leading zeroes.  */

static void
objdump_print_addr (bfd_vma vma,
                    struct disassemble_info *inf,
                    bool skip_zeroes)
{
  struct objdump_disasm_info *aux;
  asymbol *sym = NULL;
  bool skip_find = false;

  aux = (struct objdump_disasm_info *) inf->application_data;

  if (sorted_symcount < 1)
    {
      if (!no_addresses)
        {
          (*inf->fprintf_func) (inf->stream, "0x");
          objdump_print_value (vma, inf, skip_zeroes);
        }

      if (display_file_offsets)
        inf->fprintf_func (inf->stream, _(" (File Offset: 0x%lx)"),
                           (long int) (inf->section->filepos
                                       + (vma - inf->section->vma)));
      return;
    }

  if (aux->reloc != NULL
      && aux->reloc->sym_ptr_ptr != NULL
      && * aux->reloc->sym_ptr_ptr != NULL)
    {
      sym = * aux->reloc->sym_ptr_ptr;

      /* Adjust the vma to the reloc.  */
      vma += bfd_asymbol_value (sym);

      if (bfd_is_und_section (bfd_asymbol_section (sym)))
        skip_find = true;
    }

  if (!skip_find)
    sym = find_symbol_for_address (vma, inf, NULL);

  objdump_print_addr_with_sym (aux->abfd, inf->section, sym, vma, inf,
                               skip_zeroes);
}

/* Print VMA to INFO.  This function is passed to the disassembler
   routine.  */

static void
objdump_print_address (bfd_vma vma, struct disassemble_info *inf)
{
  objdump_print_addr (vma, inf, ! prefix_addresses);
}

/* Determine if the given address has a symbol associated with it.  */

static asymbol *
objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * inf)
{
  asymbol * sym;

  sym = find_symbol_for_address (vma, inf, NULL);
  if (sym != NULL && bfd_asymbol_value (sym) == vma)
    return sym;

  return NULL;
}

/* Hold the last function name and the last line number we displayed
   in a disassembly.  */

static char *prev_functionname;
static unsigned int prev_line;
static unsigned int prev_discriminator;

/* We keep a list of all files that we have seen when doing a
   disassembly with source, so that we know how much of the file to
   display.  This can be important for inlined functions.  */

struct print_file_list
{
  struct print_file_list *next;
  const char *filename;
  const char *modname;
  const char *map;
  size_t mapsize;
  const char **linemap;
  unsigned maxline;
  unsigned last_line;
  unsigned max_printed;
  int first;
};

static struct print_file_list *print_files;

/* The number of preceding context lines to show when we start
   displaying a file for the first time.  */

#define SHOW_PRECEDING_CONTEXT_LINES (5)

/* Read a complete file into memory.  */

static const char *
slurp_file (const char *fn, size_t *size, struct stat *fst)
{
#ifdef HAVE_MMAP
  int ps = getpagesize ();
  size_t msize;
#endif
  const char *map;
  int fd = open (fn, O_RDONLY | O_BINARY);

  if (fd < 0)
    return NULL;
  if (fstat (fd, fst) < 0)
    {
      close (fd);
      return NULL;
    }
  *size = fst->st_size;
#ifdef HAVE_MMAP
  msize = (*size + ps - 1) & ~(ps - 1);
  map = mmap (NULL, msize, PROT_READ, MAP_SHARED, fd, 0);
  if (map != (char *) -1L)
    {
      close (fd);
      return map;
    }
#endif
  map = (const char *) malloc (*size);
  if (!map || (size_t) read (fd, (char *) map, *size) != *size)
    {
      free ((void *) map);
      map = NULL;
    }
  close (fd);
  return map;
}

#define line_map_decrease 5

/* Precompute array of lines for a mapped file. */

static const char **
index_file (const char *map, size_t size, unsigned int *maxline)
{
  const char *p, *lstart, *end;
  int chars_per_line = 45; /* First iteration will use 40.  */
  unsigned int lineno;
  const char **linemap = NULL;
  unsigned long line_map_size = 0;

  lineno = 0;
  lstart = map;
  end = map + size;

  for (p = map; p < end; p++)
    {
      if (*p == '\n')
        {
          if (p + 1 < end && p[1] == '\r')
            p++;
        }
      else if (*p == '\r')
        {
          if (p + 1 < end && p[1] == '\n')
            p++;
        }
      else
        continue;

      /* End of line found.  */

      if (linemap == NULL || line_map_size < lineno + 1)
        {
          unsigned long newsize;

          chars_per_line -= line_map_decrease;
          if (chars_per_line <= 1)
            chars_per_line = 1;
          line_map_size = size / chars_per_line + 1;
          if (line_map_size < lineno + 1)
            line_map_size = lineno + 1;
          newsize = line_map_size * sizeof (char *);
          linemap = (const char **) xrealloc (linemap, newsize);
        }

      linemap[lineno++] = lstart;
      lstart = p + 1;
    }

  *maxline = lineno;
  return linemap;
}

/* Tries to open MODNAME, and if successful adds a node to print_files
   linked list and returns that node.  Returns NULL on failure.  */

static struct print_file_list *
try_print_file_open (const char *origname, const char *modname, struct stat *fst)
{
  struct print_file_list *p;

  p = (struct print_file_list *) xmalloc (sizeof (struct print_file_list));

  p->map = slurp_file (modname, &p->mapsize, fst);
  if (p->map == NULL)
    {
      free (p);
      return NULL;
    }

  p->linemap = index_file (p->map, p->mapsize, &p->maxline);
  p->last_line = 0;
  p->max_printed = 0;
  p->filename = origname;
  p->modname = modname;
  p->next = print_files;
  p->first = 1;
  print_files = p;
  return p;
}

/* If the source file, as described in the symtab, is not found
   try to locate it in one of the paths specified with -I
   If found, add location to print_files linked list.  */

static struct print_file_list *
update_source_path (const char *filename, bfd *abfd)
{
  struct print_file_list *p;
  const char *fname;
  struct stat fst;
  int i;

  p = try_print_file_open (filename, filename, &fst);
  if (p == NULL)
    {
      if (include_path_count == 0)
        return NULL;

      /* Get the name of the file.  */
      fname = lbasename (filename);

      /* If file exists under a new path, we need to add it to the list
         so that show_line knows about it.  */
      for (i = 0; i < include_path_count; i++)
        {
          char *modname = concat (include_paths[i], "/", fname,
                                  (const char *) 0);

          p = try_print_file_open (filename, modname, &fst);
          if (p)
            break;

          free (modname);
        }
    }

  if (p != NULL)
    {
      long mtime = bfd_get_mtime (abfd);

      if (fst.st_mtime > mtime)
        warn (_("source file %s is more recent than object file\n"),
              filename);
    }

  return p;
}

/* Print a source file line.  */

static void
print_line (struct print_file_list *p, unsigned int linenum)
{
  const char *l;
  size_t len;

  --linenum;
  if (linenum >= p->maxline)
    return;
  l = p->linemap [linenum];
  if (source_comment != NULL && strlen (l) > 0)
    printf ("%s", source_comment);
  len = strcspn (l, "\n\r");
  /* Test fwrite return value to quiet glibc warning.  */
  if (len == 0 || fwrite (l, len, 1, stdout) == 1)
    putchar ('\n');
}

/* Print a range of source code lines. */

static void
dump_lines (struct print_file_list *p, unsigned int start, unsigned int end)
{
  if (p->map == NULL)
    return;
  while (start <= end)
    {
      print_line (p, start);
      start++;
    }
}

/* Show the line number, or the source line, in a disassembly
   listing.  */

static void
show_line (bfd *abfd, asection *section, bfd_vma addr_offset)
{
  const char *filename;
  const char *functionname;
  unsigned int linenumber;
  unsigned int discriminator;
  bool reloc;
  char *path = NULL;

  if (! with_line_numbers && ! with_source_code)
    return;

  if (! bfd_find_nearest_line_discriminator (abfd, section, syms, addr_offset,
                                             &filename, &functionname,
                                             &linenumber, &discriminator))
    return;

  if (filename != NULL && *filename == '\0')
    filename = NULL;
  if (functionname != NULL && *functionname == '\0')
    functionname = NULL;

  if (filename
      && IS_ABSOLUTE_PATH (filename)
      && prefix)
    {
      char *path_up;
      const char *fname = filename;

      path = xmalloc (prefix_length + 1 + strlen (filename));

      if (prefix_length)
        memcpy (path, prefix, prefix_length);
      path_up = path + prefix_length;

      /* Build relocated filename, stripping off leading directories
         from the initial filename if requested.  */
      if (prefix_strip > 0)
        {
          int level = 0;
          const char *s;

          /* Skip selected directory levels.  */
          for (s = fname + 1; *s != '\0' && level < prefix_strip; s++)
            if (IS_DIR_SEPARATOR (*s))
              {
                fname = s;
                level++;
              }
        }

      /* Update complete filename.  */
      strcpy (path_up, fname);

      filename = path;
      reloc = true;
    }
  else
    reloc = false;

  if (with_line_numbers)
    {
      if (functionname != NULL
          && (prev_functionname == NULL
              || strcmp (functionname, prev_functionname) != 0))
        {
          char *demangle_alloc = NULL;
          if (do_demangle && functionname[0] != '\0')
            {
              /* Demangle the name.  */
              demangle_alloc = bfd_demangle (abfd, functionname,
                                             demangle_flags);
            }

          /* Demangling adds trailing parens, so don't print those.  */
          if (demangle_alloc != NULL)
            printf ("%s:\n", sanitize_string (demangle_alloc));
          else
            printf ("%s():\n", sanitize_string (functionname));

          prev_line = -1;
          free (demangle_alloc);
        }
      if (linenumber > 0
          && (linenumber != prev_line
              || discriminator != prev_discriminator))
        {
          if (discriminator > 0)
            printf ("%s:%u (discriminator %u)\n",
                    filename == NULL ? "???" : sanitize_string (filename),
                    linenumber, discriminator);
          else
            printf ("%s:%u\n", filename == NULL
                    ? "???" : sanitize_string (filename),
                    linenumber);
        }
      if (unwind_inlines)
        {
          const char *filename2;
          const char *functionname2;
          unsigned line2;

          while (bfd_find_inliner_info (abfd, &filename2, &functionname2,
                                        &line2))
            {
              printf ("inlined by %s:%u",
                      sanitize_string (filename2), line2);
              printf (" (%s)\n", sanitize_string (functionname2));
            }
        }
    }

  if (with_source_code
      && filename != NULL
      && linenumber > 0)
    {
      struct print_file_list **pp, *p;
      unsigned l;

      for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
        if (filename_cmp ((*pp)->filename, filename) == 0)
          break;
      p = *pp;

      if (p == NULL)
        {
          if (reloc)
            filename = xstrdup (filename);
          p = update_source_path (filename, abfd);
        }

      if (p != NULL && linenumber != p->last_line)
        {
          if (file_start_context && p->first)
            l = 1;
          else
            {
              l = linenumber - SHOW_PRECEDING_CONTEXT_LINES;
              if (l >= linenumber)
                l = 1;
              if (p->max_printed >= l)
                {
                  if (p->max_printed < linenumber)
                    l = p->max_printed + 1;
                  else
                    l = linenumber;
                }
            }
          dump_lines (p, l, linenumber);
          if (p->max_printed < linenumber)
            p->max_printed = linenumber;
          p->last_line = linenumber;
          p->first = 0;
        }
    }

  if (functionname != NULL
      && (prev_functionname == NULL
          || strcmp (functionname, prev_functionname) != 0))
    {
      if (prev_functionname != NULL)
        free (prev_functionname);
      prev_functionname = (char *) xmalloc (strlen (functionname) + 1);
      strcpy (prev_functionname, functionname);
    }

  if (linenumber > 0 && linenumber != prev_line)
    prev_line = linenumber;

  if (discriminator != prev_discriminator)
    prev_discriminator = discriminator;

  if (path)
    free (path);
}

/* Pseudo FILE object for strings.  */
typedef struct
{
  char *buffer;
  size_t pos;
  size_t alloc;
} SFILE;

/* sprintf to a "stream".  */

static int ATTRIBUTE_PRINTF_2
objdump_sprintf (SFILE *f, const char *format, ...)
{
  size_t n;
  va_list args;

  while (1)
    {
      size_t space = f->alloc - f->pos;

      va_start (args, format);
      n = vsnprintf (f->buffer + f->pos, space, format, args);
      va_end (args);

      if (space > n)
        break;

      f->alloc = (f->alloc + n) * 2;
      f->buffer = (char *) xrealloc (f->buffer, f->alloc);
    }
  f->pos += n;

  return n;
}

/* Code for generating (colored) diagrams of control flow start and end
   points.  */

/* Structure used to store the properties of a jump.  */

struct jump_info
{
  /* The next jump, or NULL if this is the last object.  */
  struct jump_info *next;
  /* The previous jump, or NULL if this is the first object.  */
  struct jump_info *prev;
  /* The start addresses of the jump.  */
  struct
    {
      /* The list of start addresses.  */
      bfd_vma *addresses;
      /* The number of elements.  */
      size_t count;
      /* The maximum number of elements that fit into the array.  */
      size_t max_count;
    } start;
  /* The end address of the jump.  */
  bfd_vma end;
  /* The drawing level of the jump.  */
  int level;
};

/* Construct a jump object for a jump from start
   to end with the corresponding level.  */

static struct jump_info *
jump_info_new (bfd_vma start, bfd_vma end, int level)
{
  struct jump_info *result = xmalloc (sizeof (struct jump_info));

  result->next = NULL;
  result->prev = NULL;
  result->start.addresses = xmalloc (sizeof (bfd_vma *) * 2);
  result->start.addresses[0] = start;
  result->start.count = 1;
  result->start.max_count = 2;
  result->end = end;
  result->level = level;

  return result;
}

/* Free a jump object and return the next object
   or NULL if this was the last one.  */

static struct jump_info *
jump_info_free (struct jump_info *ji)
{
  struct jump_info *result = NULL;

  if (ji)
    {
      result = ji->next;
      if (ji->start.addresses)
        free (ji->start.addresses);
      free (ji);
    }

  return result;
}

/* Get the smallest value of all start and end addresses.  */

static bfd_vma
jump_info_min_address (const struct jump_info *ji)
{
  bfd_vma min_address = ji->end;
  size_t i;

  for (i = ji->start.count; i-- > 0;)
    if (ji->start.addresses[i] < min_address)
      min_address = ji->start.addresses[i];
  return min_address;
}

/* Get the largest value of all start and end addresses.  */

static bfd_vma
jump_info_max_address (const struct jump_info *ji)
{
  bfd_vma max_address = ji->end;
  size_t i;

  for (i = ji->start.count; i-- > 0;)
    if (ji->start.addresses[i] > max_address)
      max_address = ji->start.addresses[i];
  return max_address;
}

/* Get the target address of a jump.  */

static bfd_vma
jump_info_end_address (const struct jump_info *ji)
{
  return ji->end;
}

/* Test if an address is one of the start addresses of a jump.  */

static bool
jump_info_is_start_address (const struct jump_info *ji, bfd_vma address)
{
  bool result = false;
  size_t i;

  for (i = ji->start.count; i-- > 0;)
    if (address == ji->start.addresses[i])
      {
        result = true;
        break;
      }

  return result;
}

/* Test if an address is the target address of a jump.  */

static bool
jump_info_is_end_address (const struct jump_info *ji, bfd_vma address)
{
  return (address == ji->end);
}

/* Get the difference between the smallest and largest address of a jump.  */

static bfd_vma
jump_info_size (const struct jump_info *ji)
{
  return jump_info_max_address (ji) - jump_info_min_address (ji);
}

/* Unlink a jump object from a list.  */

static void
jump_info_unlink (struct jump_info *node,
                  struct jump_info **base)
{
  if (node->next)
    node->next->prev = node->prev;
  if (node->prev)
    node->prev->next = node->next;
  else
    *base = node->next;
  node->next = NULL;
  node->prev = NULL;
}

/* Insert unlinked jump info node into a list.  */

static void
jump_info_insert (struct jump_info *node,
                  struct jump_info *target,
                  struct jump_info **base)
{
  node->next = target;
  node->prev = target->prev;
  target->prev = node;
  if (node->prev)
    node->prev->next = node;
  else
    *base = node;
}

/* Add unlinked node to the front of a list.  */

static void
jump_info_add_front (struct jump_info *node,
                     struct jump_info **base)
{
  node->next = *base;
  if (node->next)
    node->next->prev = node;
  node->prev = NULL;
  *base = node;
}

/* Move linked node to target position.  */

static void
jump_info_move_linked (struct jump_info *node,
                       struct jump_info *target,
                       struct jump_info **base)
{
  /* Unlink node.  */
  jump_info_unlink (node, base);
  /* Insert node at target position.  */
  jump_info_insert (node, target, base);
}

/* Test if two jumps intersect.  */

static bool
jump_info_intersect (const struct jump_info *a,
                     const struct jump_info *b)
{
  return ((jump_info_max_address (a) >= jump_info_min_address (b))
          && (jump_info_min_address (a) <= jump_info_max_address (b)));
}

/* Merge two compatible jump info objects.  */

static void
jump_info_merge (struct jump_info **base)
{
  struct jump_info *a;

  for (a = *base; a; a = a->next)
    {
      struct jump_info *b;

      for (b = a->next; b; b = b->next)
        {
          /* Merge both jumps into one.  */
          if (a->end == b->end)
            {
              /* Reallocate addresses.  */
              size_t needed_size = a->start.count + b->start.count;
              size_t i;

              if (needed_size > a->start.max_count)
                {
                  a->start.max_count += b->start.max_count;
                  a->start.addresses =
                    xrealloc (a->start.addresses,
                              a->start.max_count * sizeof (bfd_vma *));
                }

              /* Append start addresses.  */
              for (i = 0; i < b->start.count; ++i)
                a->start.addresses[a->start.count++] =
                  b->start.addresses[i];

              /* Remove and delete jump.  */
              struct jump_info *tmp = b->prev;
              jump_info_unlink (b, base);
              jump_info_free (b);
              b = tmp;
            }
        }
    }
}

/* Sort jumps by their size and starting point using a stable
   minsort. This could be improved if sorting performance is
   an issue, for example by using mergesort.  */

static void
jump_info_sort (struct jump_info **base)
{
  struct jump_info *current_element = *base;

  while (current_element)
    {
      struct jump_info *best_match = current_element;
      struct jump_info *runner = current_element->next;
      bfd_vma best_size = jump_info_size (best_match);

      while (runner)
        {
          bfd_vma runner_size = jump_info_size (runner);

          if ((runner_size < best_size)
              || ((runner_size == best_size)
                  && (jump_info_min_address (runner)
                      < jump_info_min_address (best_match))))
            {
              best_match = runner;
              best_size = runner_size;
            }

          runner = runner->next;
        }

      if (best_match == current_element)
        current_element = current_element->next;
      else
        jump_info_move_linked (best_match, current_element, base);
    }
}

/* Visualize all jumps at a given address.  */

static void
jump_info_visualize_address (bfd_vma address,
                             int max_level,
                             char *line_buffer,
                             uint8_t *color_buffer)
{
  struct jump_info *ji = detected_jumps;
  size_t len = (max_level + 1) * 3;

  /* Clear line buffer.  */
  memset (line_buffer, ' ', len);
  memset (color_buffer, 0, len);

  /* Iterate over jumps and add their ASCII art.  */
  while (ji)
    {
      /* Discard jumps that are never needed again.  */
      if (jump_info_max_address (ji) < address)
        {
          struct jump_info *tmp = ji;

          ji = ji->next;
          jump_info_unlink (tmp, &detected_jumps);
          jump_info_free (tmp);
          continue;
        }

      /* This jump intersects with the current address.  */
      if (jump_info_min_address (ji) <= address)
        {
          /* Hash target address to get an even
             distribution between all values.  */
          bfd_vma hash_address = jump_info_end_address (ji);
          uint8_t color = iterative_hash_object (hash_address, 0);
          /* Fetch line offset.  */
          int offset = (max_level - ji->level) * 3;

          /* Draw start line.  */
          if (jump_info_is_start_address (ji, address))
            {
              size_t i = offset + 1;

              for (; i < len - 1; ++i)
                if (line_buffer[i] == ' ')
                  {
                    line_buffer[i] = '-';
                    color_buffer[i] = color;
                  }

              if (line_buffer[i] == ' ')
                {
                  line_buffer[i] = '-';
                  color_buffer[i] = color;
                }
              else if (line_buffer[i] == '>')
                {
                  line_buffer[i] = 'X';
                  color_buffer[i] = color;
                }

              if (line_buffer[offset] == ' ')
                {
                  if (address <= ji->end)
                    line_buffer[offset] =
                      (jump_info_min_address (ji) == address) ? '/': '+';
                  else
                    line_buffer[offset] =
                      (jump_info_max_address (ji) == address) ? '\\': '+';
                  color_buffer[offset] = color;
                }
            }
          /* Draw jump target.  */
          else if (jump_info_is_end_address (ji, address))
            {
              size_t i = offset + 1;

              for (; i < len - 1; ++i)
                if (line_buffer[i] == ' ')
                  {
                    line_buffer[i] = '-';
                    color_buffer[i] = color;
                  }

              if (line_buffer[i] == ' ')
                {
                  line_buffer[i] = '>';
                  color_buffer[i] = color;
                }
              else if (line_buffer[i] == '-')
                {
                  line_buffer[i] = 'X';
                  color_buffer[i] = color;
                }

              if (line_buffer[offset] == ' ')
                {
                  if (jump_info_min_address (ji) < address)
                    line_buffer[offset] =
                      (jump_info_max_address (ji) > address) ? '>' : '\\';
                  else
                    line_buffer[offset] = '/';
                  color_buffer[offset] = color;
                }
            }
          /* Draw intermediate line segment.  */
          else if (line_buffer[offset] == ' ')
            {
              line_buffer[offset] = '|';
              color_buffer[offset] = color;
            }
        }

      ji = ji->next;
    }
}

/* Clone of disassemble_bytes to detect jumps inside a function.  */
/* FIXME: is this correct? Can we strip it down even further?  */

static struct jump_info *
disassemble_jumps (struct disassemble_info * inf,
                   disassembler_ftype        disassemble_fn,
                   bfd_vma                   start_offset,
                   bfd_vma                   stop_offset,
                   bfd_vma                   rel_offset,
                   arelent ***               relppp,
                   arelent **                relppend)
{
  struct objdump_disasm_info *aux;
  struct jump_info *jumps = NULL;
  asection *section;
  bfd_vma addr_offset;
  unsigned int opb = inf->octets_per_byte;
  int octets = opb;
  SFILE sfile;

  aux = (struct objdump_disasm_info *) inf->application_data;
  section = inf->section;

  sfile.alloc = 120;
  sfile.buffer = (char *) xmalloc (sfile.alloc);
  sfile.pos = 0;

  inf->insn_info_valid = 0;
  inf->fprintf_func = (fprintf_ftype) objdump_sprintf;
  inf->stream = &sfile;

  addr_offset = start_offset;
  while (addr_offset < stop_offset)
    {
      int previous_octets;

      /* Remember the length of the previous instruction.  */
      previous_octets = octets;
      octets = 0;

      sfile.pos = 0;
      inf->bytes_per_line = 0;
      inf->bytes_per_chunk = 0;
      inf->flags = ((disassemble_all ? DISASSEMBLE_DATA : 0)
                    | (wide_output ? WIDE_OUTPUT : 0));
      if (machine)
        inf->flags |= USER_SPECIFIED_MACHINE_TYPE;

      if (inf->disassembler_needs_relocs
          && (bfd_get_file_flags (aux->abfd) & EXEC_P) == 0
          && (bfd_get_file_flags (aux->abfd) & DYNAMIC) == 0
          && *relppp < relppend)
        {
          bfd_signed_vma distance_to_rel;

          distance_to_rel = (**relppp)->address - (rel_offset + addr_offset);

          /* Check to see if the current reloc is associated with
             the instruction that we are about to disassemble.  */
          if (distance_to_rel == 0
              /* FIXME: This is wrong.  We are trying to catch
                 relocs that are addressed part way through the
                 current instruction, as might happen with a packed
                 VLIW instruction.  Unfortunately we do not know the
                 length of the current instruction since we have not
                 disassembled it yet.  Instead we take a guess based
                 upon the length of the previous instruction.  The
                 proper solution is to have a new target-specific
                 disassembler function which just returns the length
                 of an instruction at a given address without trying
                 to display its disassembly. */
              || (distance_to_rel > 0
                && distance_to_rel < (bfd_signed_vma) (previous_octets/ opb)))
            {
              inf->flags |= INSN_HAS_RELOC;
            }
        }

      if (! disassemble_all
          && (section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
          == (SEC_CODE | SEC_HAS_CONTENTS))
        /* Set a stop_vma so that the disassembler will not read
           beyond the next symbol.  We assume that symbols appear on
           the boundaries between instructions.  We only do this when
           disassembling code of course, and when -D is in effect.  */
        inf->stop_vma = section->vma + stop_offset;

      inf->stop_offset = stop_offset;

      /* Extract jump information.  */
      inf->insn_info_valid = 0;
      octets = (*disassemble_fn) (section->vma + addr_offset, inf);
      /* Test if a jump was detected.  */
      if (inf->insn_info_valid
          && ((inf->insn_type == dis_branch)
              || (inf->insn_type == dis_condbranch)
              || (inf->insn_type == dis_jsr)
              || (inf->insn_type == dis_condjsr))
          && (inf->target >= section->vma + start_offset)
          && (inf->target < section->vma + stop_offset))
        {
          struct jump_info *ji =
            jump_info_new (section->vma + addr_offset, inf->target, -1);
          jump_info_add_front (ji, &jumps);
        }

      inf->stop_vma = 0;

      addr_offset += octets / opb;
    }

  inf->fprintf_func = (fprintf_ftype) fprintf;
  inf->stream = stdout;

  free (sfile.buffer);

  /* Merge jumps.  */
  jump_info_merge (&jumps);
  /* Process jumps.  */
  jump_info_sort (&jumps);

  /* Group jumps by level.  */
  struct jump_info *last_jump = jumps;
  int max_level = -1;

  while (last_jump)
    {
      /* The last jump is part of the next group.  */
      struct jump_info *base = last_jump;
      /* Increment level.  */
      base->level = ++max_level;

      /* Find jumps that can be combined on the same
         level, with the largest jumps tested first.
         This has the advantage that large jumps are on
         lower levels and do not intersect with small
         jumps that get grouped on higher levels.  */
      struct jump_info *exchange_item = last_jump->next;
      struct jump_info *it = exchange_item;

      for (; it; it = it->next)
        {
          /* Test if the jump intersects with any
             jump from current group.  */
          bool ok = true;
          struct jump_info *it_collision;

          for (it_collision = base;
               it_collision != exchange_item;
               it_collision = it_collision->next)
            {
              /* This jump intersects so we leave it out.  */
              if (jump_info_intersect (it_collision, it))
                {
                  ok = false;
                  break;
                }
            }

          /* Add jump to group.  */
          if (ok)
            {
              /* Move current element to the front.  */
              if (it != exchange_item)
                {
                  struct jump_info *save = it->prev;
                  jump_info_move_linked (it, exchange_item, &jumps);
                  last_jump = it;
                  it = save;
                }
              else
                {
                  last_jump = exchange_item;
                  exchange_item = exchange_item->next;
                }
              last_jump->level = max_level;
            }
        }

      /* Move to next group.  */
      last_jump = exchange_item;
    }

  return jumps;
}

/* The number of zeroes we want to see before we start skipping them.
   The number is arbitrarily chosen.  */

#define DEFAULT_SKIP_ZEROES 8

/* The number of zeroes to skip at the end of a section.  If the
   number of zeroes at the end is between SKIP_ZEROES_AT_END and
   SKIP_ZEROES, they will be disassembled.  If there are fewer than
   SKIP_ZEROES_AT_END, they will be skipped.  This is a heuristic
   attempt to avoid disassembling zeroes inserted by section
   alignment.  */

#define DEFAULT_SKIP_ZEROES_AT_END 3

static int
null_print (const void * stream ATTRIBUTE_UNUSED, const char * format ATTRIBUTE_UNUSED, ...)
{
  return 1;
}

/* Print out jump visualization.  */

static void
print_jump_visualisation (bfd_vma addr, int max_level, char *line_buffer,
                          uint8_t *color_buffer)
{
  if (!line_buffer)
    return;

  jump_info_visualize_address (addr, max_level, line_buffer, color_buffer);

  size_t line_buffer_size = strlen (line_buffer);
  char last_color = 0;
  size_t i;

  for (i = 0; i <= line_buffer_size; ++i)
    {
      if (color_output)
        {
          uint8_t color = (i < line_buffer_size) ? color_buffer[i]: 0;

          if (color != last_color)
            {
              if (color)
                if (extended_color_output)
                  /* Use extended 8bit color, but
                     do not choose dark colors.  */
                  printf ("\033[38;5;%dm", 124 + (color % 108));
                else
                  /* Use simple terminal colors.  */
                  printf ("\033[%dm", 31 + (color % 7));
              else
                /* Clear color.  */
                printf ("\033[0m");
              last_color = color;
            }
        }
      putchar ((i < line_buffer_size) ? line_buffer[i]: ' ');
    }
}

/* Disassemble some data in memory between given values.  */

static void
disassemble_bytes (struct disassemble_info *inf,
                   disassembler_ftype disassemble_fn,
                   bool insns,
                   bfd_byte *data,
                   bfd_vma start_offset,
                   bfd_vma stop_offset,
                   bfd_vma rel_offset,
                   arelent ***relppp,
                   arelent **relppend)
{
  struct objdump_disasm_info *aux;
  asection *section;
  unsigned int octets_per_line;
  unsigned int skip_addr_chars;
  bfd_vma addr_offset;
  unsigned int opb = inf->octets_per_byte;
  unsigned int skip_zeroes = inf->skip_zeroes;
  unsigned int skip_zeroes_at_end = inf->skip_zeroes_at_end;
  size_t octets;
  SFILE sfile;

  aux = (struct objdump_disasm_info *) inf->application_data;
  section = inf->section;

  sfile.alloc = 120;
  sfile.buffer = (char *) xmalloc (sfile.alloc);
  sfile.pos = 0;

  if (insn_width)
    octets_per_line = insn_width;
  else if (insns)
    octets_per_line = 4;
  else
    octets_per_line = 16;

  /* Figure out how many characters to skip at the start of an
     address, to make the disassembly look nicer.  We discard leading
     zeroes in chunks of 4, ensuring that there is always a leading
     zero remaining.  */
  skip_addr_chars = 0;
  if (!no_addresses && !prefix_addresses)
    {
      char buf[30];

      bfd_sprintf_vma (aux->abfd, buf, section->vma + section->size / opb);

      while (buf[skip_addr_chars] == '0')
        ++skip_addr_chars;

      /* Don't discard zeros on overflow.  */
      if (buf[skip_addr_chars] == '\0' && section->vma != 0)
        skip_addr_chars = 0;

      if (skip_addr_chars != 0)
        skip_addr_chars = (skip_addr_chars - 1) & -4;
    }

  inf->insn_info_valid = 0;

  /* Determine maximum level. */
  uint8_t *color_buffer = NULL;
  char *line_buffer = NULL;
  int max_level = -1;

  /* Some jumps were detected.  */
  if (detected_jumps)
    {
      struct jump_info *ji;

      /* Find maximum jump level.  */
      for (ji = detected_jumps; ji; ji = ji->next)
        {
          if (ji->level > max_level)
            max_level = ji->level;
        }

      /* Allocate buffers.  */
      size_t len = (max_level + 1) * 3 + 1;
      line_buffer = xmalloc (len);
      line_buffer[len - 1] = 0;
      color_buffer = xmalloc (len);
      color_buffer[len - 1] = 0;
    }

  addr_offset = start_offset;
  while (addr_offset < stop_offset)
    {
      bool need_nl = false;

      octets = 0;

      /* Make sure we don't use relocs from previous instructions.  */
      aux->reloc = NULL;

      /* If we see more than SKIP_ZEROES octets of zeroes, we just
         print `...'.  */
      if (! disassemble_zeroes)
        for (; addr_offset * opb + octets < stop_offset * opb; octets++)
          if (data[addr_offset * opb + octets] != 0)
            break;
      if (! disassemble_zeroes
          && (inf->insn_info_valid == 0
              || inf->branch_delay_insns == 0)
          && (octets >= skip_zeroes
              || (addr_offset * opb + octets == stop_offset * opb
                  && octets < skip_zeroes_at_end)))
        {
          /* If there are more nonzero octets to follow, we only skip
             zeroes in multiples of 4, to try to avoid running over
             the start of an instruction which happens to start with
             zero.  */
          if (addr_offset * opb + octets != stop_offset * opb)
            octets &= ~3;

          /* If we are going to display more data, and we are displaying
             file offsets, then tell the user how many zeroes we skip
             and the file offset from where we resume dumping.  */
          if (display_file_offsets
              && addr_offset + octets / opb < stop_offset)
            printf (_("\t... (skipping %lu zeroes, "
                      "resuming at file offset: 0x%lx)\n"),
                    (unsigned long) (octets / opb),
                    (unsigned long) (section->filepos
                                     + addr_offset + octets / opb));
          else
            printf ("\t...\n");
        }
      else
        {
          char buf[50];
          unsigned int bpc = 0;
          unsigned int pb = 0;

          if (with_line_numbers || with_source_code)
            show_line (aux->abfd, section, addr_offset);

          if (no_addresses)
            printf ("\t");
          else if (!prefix_addresses)
            {
              char *s;

              bfd_sprintf_vma (aux->abfd, buf, section->vma + addr_offset);
              for (s = buf + skip_addr_chars; *s == '0'; s++)
                *s = ' ';
              if (*s == '\0')
                *--s = '0';
              printf ("%s:\t", buf + skip_addr_chars);
            }
          else
            {
              aux->require_sec = true;
              objdump_print_address (section->vma + addr_offset, inf);
              aux->require_sec = false;
              putchar (' ');
            }

          print_jump_visualisation (section->vma + addr_offset,
                                    max_level, line_buffer,
                                    color_buffer);

          if (insns)
            {
              int insn_size;

              sfile.pos = 0;
              inf->fprintf_func = (fprintf_ftype) objdump_sprintf;
              inf->stream = &sfile;
              inf->bytes_per_line = 0;
              inf->bytes_per_chunk = 0;
              inf->flags = ((disassemble_all ? DISASSEMBLE_DATA : 0)
                            | (wide_output ? WIDE_OUTPUT : 0));
              if (machine)
                inf->flags |= USER_SPECIFIED_MACHINE_TYPE;

              if (inf->disassembler_needs_relocs
                  && (bfd_get_file_flags (aux->abfd) & EXEC_P) == 0
                  && (bfd_get_file_flags (aux->abfd) & DYNAMIC) == 0
                  && *relppp < relppend)
                {
                  bfd_signed_vma distance_to_rel;
                  int max_reloc_offset
                    = aux->abfd->arch_info->max_reloc_offset_into_insn;

                  distance_to_rel = ((**relppp)->address - rel_offset
                                     - addr_offset);

                  insn_size = 0;
                  if (distance_to_rel > 0
                      && (max_reloc_offset < 0
                          || distance_to_rel <= max_reloc_offset))
                    {
                      /* This reloc *might* apply to the current insn,
                         starting somewhere inside it.  Discover the length
                         of the current insn so that the check below will
                         work.  */
                      if (insn_width)
                        insn_size = insn_width;
                      else
                        {
                          /* We find the length by calling the dissassembler
                             function with a dummy print handler.  This should
                             work unless the disassembler is not expecting to
                             be called multiple times for the same address.

                             This does mean disassembling the instruction
                             twice, but we only do this when there is a high
                             probability that there is a reloc that will
                             affect the instruction.  */
                          inf->fprintf_func = (fprintf_ftype) null_print;
                          insn_size = disassemble_fn (section->vma
                                                      + addr_offset, inf);
                          inf->fprintf_func = (fprintf_ftype) objdump_sprintf;
                        }
                    }

                  /* Check to see if the current reloc is associated with
                     the instruction that we are about to disassemble.  */
                  if (distance_to_rel == 0
                      || (distance_to_rel > 0
                          && distance_to_rel < insn_size / (int) opb))
                    {
                      inf->flags |= INSN_HAS_RELOC;
                      aux->reloc = **relppp;
                    }
                }

              if (! disassemble_all
                  && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
                      == (SEC_CODE | SEC_HAS_CONTENTS)))
                /* Set a stop_vma so that the disassembler will not read
                   beyond the next symbol.  We assume that symbols appear on
                   the boundaries between instructions.  We only do this when
                   disassembling code of course, and when -D is in effect.  */
                inf->stop_vma = section->vma + stop_offset;

              inf->stop_offset = stop_offset;
              insn_size = (*disassemble_fn) (section->vma + addr_offset, inf);
              octets = insn_size;

              inf->stop_vma = 0;
              inf->fprintf_func = (fprintf_ftype) fprintf;
              inf->stream = stdout;
              if (insn_width == 0 && inf->bytes_per_line != 0)
                octets_per_line = inf->bytes_per_line;
              if (insn_size < (int) opb)
                {
                  if (sfile.pos)
                    printf ("%s\n", sfile.buffer);
                  if (insn_size >= 0)
                    {
                      non_fatal (_("disassemble_fn returned length %d"),
                                 insn_size);
                      exit_status = 1;
                    }
                  break;
                }
            }
          else
            {
              bfd_vma j;

              octets = octets_per_line;
              if (addr_offset + octets / opb > stop_offset)
                octets = (stop_offset - addr_offset) * opb;

              for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
                {
                  if (ISPRINT (data[j]))
                    buf[j - addr_offset * opb] = data[j];
                  else
                    buf[j - addr_offset * opb] = '.';
                }
              buf[j - addr_offset * opb] = '\0';
            }

          if (prefix_addresses
              ? show_raw_insn > 0
              : show_raw_insn >= 0)
            {
              bfd_vma j;

              /* If ! prefix_addresses and ! wide_output, we print
                 octets_per_line octets per line.  */
              pb = octets;
              if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
                pb = octets_per_line;

              if (inf->bytes_per_chunk)
                bpc = inf->bytes_per_chunk;
              else
                bpc = 1;

              for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
                {
                  /* PR 21580: Check for a buffer ending early.  */
                  if (j + bpc <= stop_offset * opb)
                    {
                      unsigned int k;

                      if (inf->display_endian == BFD_ENDIAN_LITTLE)
                        {
                          for (k = bpc; k-- != 0; )
                            printf ("%02x", (unsigned) data[j + k]);
                        }
                      else
                        {
                          for (k = 0; k < bpc; k++)
                            printf ("%02x", (unsigned) data[j + k]);
                        }
                    }
                  putchar (' ');
                }

              for (; pb < octets_per_line; pb += bpc)
                {
                  unsigned int k;

                  for (k = 0; k < bpc; k++)
                    printf ("  ");
                  putchar (' ');
                }

              /* Separate raw data from instruction by extra space.  */
              if (insns)
                putchar ('\t');
              else
                printf ("    ");
            }

          if (! insns)
            printf ("%s", buf);
          else if (sfile.pos)
            printf ("%s", sfile.buffer);

          if (prefix_addresses
              ? show_raw_insn > 0
              : show_raw_insn >= 0)
            {
              while (pb < octets)
                {
                  bfd_vma j;
                  char *s;

                  putchar ('\n');
                  j = addr_offset * opb + pb;

                  if (no_addresses)
                    printf ("\t");
                  else
                    {
                      bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb);
                      for (s = buf + skip_addr_chars; *s == '0'; s++)
                        *s = ' ';
                      if (*s == '\0')
                        *--s = '0';
                      printf ("%s:\t", buf + skip_addr_chars);
                    }

                  print_jump_visualisation (section->vma + j / opb,
                                            max_level, line_buffer,
                                            color_buffer);

                  pb += octets_per_line;
                  if (pb > octets)
                    pb = octets;
                  for (; j < addr_offset * opb + pb; j += bpc)
                    {
                      /* PR 21619: Check for a buffer ending early.  */
                      if (j + bpc <= stop_offset * opb)
                        {
                          unsigned int k;

                          if (inf->display_endian == BFD_ENDIAN_LITTLE)
                            {
                              for (k = bpc; k-- != 0; )
                                printf ("%02x", (unsigned) data[j + k]);
                            }
                          else
                            {
                              for (k = 0; k < bpc; k++)
                                printf ("%02x", (unsigned) data[j + k]);
                            }
                        }
                      putchar (' ');
                    }
                }
            }

          if (!wide_output)
            putchar ('\n');
          else
            need_nl = true;
        }

      while ((*relppp) < relppend
             && (**relppp)->address < rel_offset + addr_offset + octets / opb)
        {
          if (dump_reloc_info || dump_dynamic_reloc_info)
            {
              arelent *q;

              q = **relppp;

              if (wide_output)
                putchar ('\t');
              else
                printf ("\t\t\t");

              if (!no_addresses)
                {
                  objdump_print_value (section->vma - rel_offset + q->address,
                                       inf, true);
                  printf (": ");
                }

              if (q->howto == NULL)
                printf ("*unknown*\t");
              else if (q->howto->name)
                printf ("%s\t", q->howto->name);
              else
                printf ("%d\t", q->howto->type);

              if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
                printf ("*unknown*");
              else
                {
                  const char *sym_name;

                  sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
                  if (sym_name != NULL && *sym_name != '\0')
                    objdump_print_symname (aux->abfd, inf, *q->sym_ptr_ptr);
                  else
                    {
                      asection *sym_sec;

                      sym_sec = bfd_asymbol_section (*q->sym_ptr_ptr);
                      sym_name = bfd_section_name (sym_sec);
                      if (sym_name == NULL || *sym_name == '\0')
                        sym_name = "*unknown*";
                      printf ("%s", sanitize_string (sym_name));
                    }
                }

              if (q->addend)
                {
                  bfd_vma addend = q->addend;
                  if ((bfd_signed_vma) addend < 0)
                    {
                      printf ("-0x");
                      addend = -addend;
                    }
                  else
                    printf ("+0x");
                  objdump_print_value (addend, inf, true);
                }

              printf ("\n");
              need_nl = false;
            }
          ++(*relppp);
        }

      if (need_nl)
        printf ("\n");

      addr_offset += octets / opb;
    }

  free (sfile.buffer);
  free (line_buffer);
  free (color_buffer);
}

static void
disassemble_section (bfd *abfd, asection *section, void *inf)
{
  const struct elf_backend_data *bed;
  bfd_vma sign_adjust = 0;
  struct disassemble_info *pinfo = (struct disassemble_info *) inf;
  struct objdump_disasm_info *paux;
  unsigned int opb = pinfo->octets_per_byte;
  bfd_byte *data = NULL;
  bfd_size_type datasize = 0;
  arelent **rel_pp = NULL;
  arelent **rel_ppstart = NULL;
  arelent **rel_ppend;
  bfd_vma stop_offset;
  asymbol *sym = NULL;
  long place = 0;
  long rel_count;
  bfd_vma rel_offset;
  unsigned long addr_offset;
  bool do_print;
  enum loop_control
  {
   stop_offset_reached,
   function_sym,
   next_sym
  } loop_until;

  /* Sections that do not contain machine
     code are not normally disassembled.  */
  if (! disassemble_all
      && only_list == NULL
      && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
          != (SEC_CODE | SEC_HAS_CONTENTS)))
    return;

  if (! process_section_p (section))
    return;

  datasize = bfd_section_size (section);
  if (datasize == 0)
    return;

  if (start_address == (bfd_vma) -1
      || start_address < section->vma)
    addr_offset = 0;
  else
    addr_offset = start_address - section->vma;

  if (stop_address == (bfd_vma) -1)
    stop_offset = datasize / opb;
  else
    {
      if (stop_address < section->vma)
        stop_offset = 0;
      else
        stop_offset = stop_address - section->vma;
      if (stop_offset > datasize / opb)
        stop_offset = datasize / opb;
    }

  if (addr_offset >= stop_offset)
    return;

  /* Decide which set of relocs to use.  Load them if necessary.  */
  paux = (struct objdump_disasm_info *) pinfo->application_data;
  if (pinfo->dynrelbuf && dump_dynamic_reloc_info)
    {
      rel_pp = pinfo->dynrelbuf;
      rel_count = pinfo->dynrelcount;
      /* Dynamic reloc addresses are absolute, non-dynamic are section
         relative.  REL_OFFSET specifies the reloc address corresponding
         to the start of this section.  */
      rel_offset = section->vma;
    }
  else
    {
      rel_count = 0;
      rel_pp = NULL;
      rel_offset = 0;

      if ((section->flags & SEC_RELOC) != 0
          && (dump_reloc_info || pinfo->disassembler_needs_relocs))
        {
          long relsize;

          relsize = bfd_get_reloc_upper_bound (abfd, section);
          if (relsize < 0)
            bfd_fatal (bfd_get_filename (abfd));

          if (relsize > 0)
            {
              rel_ppstart = rel_pp = (arelent **) xmalloc (relsize);
              rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
              if (rel_count < 0)
                bfd_fatal (bfd_get_filename (abfd));

              /* Sort the relocs by address.  */
              qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
            }
        }
    }
  rel_ppend = PTR_ADD (rel_pp, rel_count);

  if (!bfd_malloc_and_get_section (abfd, section, &data))
    {
      non_fatal (_("Reading section %s failed because: %s"),
                 section->name, bfd_errmsg (bfd_get_error ()));
      return;
    }

  pinfo->buffer = data;
  pinfo->buffer_vma = section->vma;
  pinfo->buffer_length = datasize;
  pinfo->section = section;

  /* Sort the symbols into value and section order.  */
  compare_section = section;
  if (sorted_symcount > 1)
    qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);

  /* Skip over the relocs belonging to addresses below the
     start address.  */
  while (rel_pp < rel_ppend
         && (*rel_pp)->address < rel_offset + addr_offset)
    ++rel_pp;

  printf (_("\nDisassembly of section %s:\n"), sanitize_string (section->name));

  /* Find the nearest symbol forwards from our current position.  */
  paux->require_sec = true;
  sym = (asymbol *) find_symbol_for_address (section->vma + addr_offset,
                                             (struct disassemble_info *) inf,
                                             &place);
  paux->require_sec = false;

  /* PR 9774: If the target used signed addresses then we must make
     sure that we sign extend the value that we calculate for 'addr'
     in the loop below.  */
  if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
      && (bed = get_elf_backend_data (abfd)) != NULL
      && bed->sign_extend_vma)
    sign_adjust = (bfd_vma) 1 << (bed->s->arch_size - 1);

  /* Disassemble a block of instructions up to the address associated with
     the symbol we have just found.  Then print the symbol and find the
     next symbol on.  Repeat until we have disassembled the entire section
     or we have reached the end of the address range we are interested in.  */
  do_print = paux->symbol == NULL;
  loop_until = stop_offset_reached;

  while (addr_offset < stop_offset)
    {
      bfd_vma addr;
      asymbol *nextsym;
      bfd_vma nextstop_offset;
      bool insns;

      addr = section->vma + addr_offset;
      addr = ((addr & ((sign_adjust << 1) - 1)) ^ sign_adjust) - sign_adjust;

      if (sym != NULL && bfd_asymbol_value (sym) <= addr)
        {
          int x;

          for (x = place;
               (x < sorted_symcount
                && (bfd_asymbol_value (sorted_syms[x]) <= addr));
               ++x)
            continue;

          pinfo->symbols = sorted_syms + place;
          pinfo->num_symbols = x - place;
          pinfo->symtab_pos = place;
        }
      else
        {
          pinfo->symbols = NULL;
          pinfo->num_symbols = 0;
          pinfo->symtab_pos = -1;
        }

      /* If we are only disassembling from a specific symbol,
         check to see if we should start or stop displaying.  */
      if (sym && paux->symbol)
        {
          if (do_print)
            {
              /* See if we should stop printing.  */
              switch (loop_until)
                {
                case function_sym:
                  if (sym->flags & BSF_FUNCTION)
                    do_print = false;
                  break;

                case stop_offset_reached:
                  /* Handled by the while loop.  */
                  break;

                case next_sym:
                  /* FIXME: There is an implicit assumption here
                     that the name of sym is different from
                     paux->symbol.  */
                  if (! bfd_is_local_label (abfd, sym))
                    do_print = false;
                  break;
                }
            }
          else
            {
              const char * name = bfd_asymbol_name (sym);
              char * alloc = NULL;

              if (do_demangle && name[0] != '\0')
                {
                  /* Demangle the name.  */
                  alloc = bfd_demangle (abfd, name, demangle_flags);
                  if (alloc != NULL)
                    name = alloc;
                }

              /* We are not currently printing.  Check to see
                 if the current symbol matches the requested symbol.  */
              if (streq (name, paux->symbol))
                {
                  do_print = true;

                  if (sym->flags & BSF_FUNCTION)
                    {
                      if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
                          && ((elf_symbol_type *) sym)->internal_elf_sym.st_size > 0)
                        {
                          /* Sym is a function symbol with a size associated
                             with it.  Turn on automatic disassembly for the
                             next VALUE bytes.  */
                          stop_offset = addr_offset
                            + ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
                          loop_until = stop_offset_reached;
                        }
                      else
                        {
                          /* Otherwise we need to tell the loop heuristic to
                             loop until the next function symbol is encountered.  */
                          loop_until = function_sym;
                        }
                    }
                  else
                    {
                      /* Otherwise loop until the next symbol is encountered.  */
                      loop_until = next_sym;
                    }
                }

              free (alloc);
            }
        }

      if (! prefix_addresses && do_print)
        {
          pinfo->fprintf_func (pinfo->stream, "\n");
          objdump_print_addr_with_sym (abfd, section, sym, addr,
                                       pinfo, false);
          pinfo->fprintf_func (pinfo->stream, ":\n");
        }

      if (sym != NULL && bfd_asymbol_value (sym) > addr)
        nextsym = sym;
      else if (sym == NULL)
        nextsym = NULL;
      else
        {
#define is_valid_next_sym(SYM) \
  (strcmp (bfd_section_name ((SYM)->section), bfd_section_name (section)) == 0 \
   && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
   && pinfo->symbol_is_valid (SYM, pinfo))

          /* Search forward for the next appropriate symbol in
             SECTION.  Note that all the symbols are sorted
             together into one big array, and that some sections
             may have overlapping addresses.  */
          while (place < sorted_symcount
                 && ! is_valid_next_sym (sorted_syms [place]))
            ++place;

          if (place >= sorted_symcount)
            nextsym = NULL;
          else
            nextsym = sorted_syms[place];
        }

      if (sym != NULL && bfd_asymbol_value (sym) > addr)
        nextstop_offset = bfd_asymbol_value (sym) - section->vma;
      else if (nextsym == NULL)
        nextstop_offset = stop_offset;
      else
        nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;

      if (nextstop_offset > stop_offset
          || nextstop_offset <= addr_offset)
        nextstop_offset = stop_offset;

      /* If a symbol is explicitly marked as being an object
         rather than a function, just dump the bytes without
         disassembling them.  */
      if (disassemble_all
          || sym == NULL
          || sym->section != section
          || bfd_asymbol_value (sym) > addr
          || ((sym->flags & BSF_OBJECT) == 0
              && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
                  == NULL)
              && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
                  == NULL))
          || (sym->flags & BSF_FUNCTION) != 0)
        insns = true;
      else
        insns = false;

      if (do_print)
        {
          /* Resolve symbol name.  */
          if (visualize_jumps && abfd && sym && sym->name)
            {
              struct disassemble_info di;
              SFILE sf;

              sf.alloc = strlen (sym->name) + 40;
              sf.buffer = (char*) xmalloc (sf.alloc);
              sf.pos = 0;
              di.fprintf_func = (fprintf_ftype) objdump_sprintf;
              di.stream = &sf;

              objdump_print_symname (abfd, &di, sym);

              /* Fetch jump information.  */
              detected_jumps = disassemble_jumps
                (pinfo, paux->disassemble_fn,
                 addr_offset, nextstop_offset,
                 rel_offset, &rel_pp, rel_ppend);

              /* Free symbol name.  */
              free (sf.buffer);
            }

          /* Add jumps to output.  */
          disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
                             addr_offset, nextstop_offset,
                             rel_offset, &rel_pp, rel_ppend);

          /* Free jumps.  */
          while (detected_jumps)
            {
              detected_jumps = jump_info_free (detected_jumps);
            }
        }

      addr_offset = nextstop_offset;
      sym = nextsym;
    }

  free (data);

  if (rel_ppstart != NULL)
    free (rel_ppstart);
}

/* Disassemble the contents of an object file.  */

static void
disassemble_data (bfd *abfd)
{
  struct disassemble_info disasm_info;
  struct objdump_disasm_info aux;
  long i;

  print_files = NULL;
  prev_functionname = NULL;
  prev_line = -1;
  prev_discriminator = 0;

  /* We make a copy of syms to sort.  We don't want to sort syms
     because that will screw up the relocs.  */
  sorted_symcount = symcount ? symcount : dynsymcount;
  sorted_syms = (asymbol **) xmalloc ((sorted_symcount + synthcount)
                                      * sizeof (asymbol *));
  if (sorted_symcount != 0)
    {
      memcpy (sorted_syms, symcount ? syms : dynsyms,
              sorted_symcount * sizeof (asymbol *));

      sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
    }

  for (i = 0; i < synthcount; ++i)
    {
      sorted_syms[sorted_symcount] = synthsyms + i;
      ++sorted_symcount;
    }

  init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);

  disasm_info.application_data = (void *) &aux;
  aux.abfd = abfd;
  aux.require_sec = false;
  disasm_info.dynrelbuf = NULL;
  disasm_info.dynrelcount = 0;
  aux.reloc = NULL;
  aux.symbol = disasm_sym;

  disasm_info.print_address_func = objdump_print_address;
  disasm_info.symbol_at_address_func = objdump_symbol_at_address;

  if (machine != NULL)
    {
      const bfd_arch_info_type *inf = bfd_scan_arch (machine);

      if (inf == NULL)
        fatal (_("can't use supplied machine %s"), machine);

      abfd->arch_info = inf;
    }

  if (endian != BFD_ENDIAN_UNKNOWN)
    {
      struct bfd_target *xvec;

      xvec = (struct bfd_target *) xmalloc (sizeof (struct bfd_target));
      memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
      xvec->byteorder = endian;
      abfd->xvec = xvec;
    }

  /* Use libopcodes to locate a suitable disassembler.  */
  aux.disassemble_fn = disassembler (bfd_get_arch (abfd),
                                     bfd_big_endian (abfd),
                                     bfd_get_mach (abfd), abfd);
  if (!aux.disassemble_fn)
    {
      non_fatal (_("can't disassemble for architecture %s\n"),
                 bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
      exit_status = 1;
      return;
    }

  disasm_info.flavour = bfd_get_flavour (abfd);
  disasm_info.arch = bfd_get_arch (abfd);
  disasm_info.mach = bfd_get_mach (abfd);
  disasm_info.disassembler_options = disassembler_options;
  disasm_info.octets_per_byte = bfd_octets_per_byte (abfd, NULL);
  disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
  disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
  disasm_info.disassembler_needs_relocs = false;

  if (bfd_big_endian (abfd))
    disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
  else if (bfd_little_endian (abfd))
    disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
  else
    /* ??? Aborting here seems too drastic.  We could default to big or little
       instead.  */
    disasm_info.endian = BFD_ENDIAN_UNKNOWN;

  disasm_info.endian_code = disasm_info.endian;

  /* Allow the target to customize the info structure.  */
  disassemble_init_for_target (& disasm_info);

  /* Pre-load the dynamic relocs as we may need them during the disassembly.  */
  long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);

  if (relsize < 0 && dump_dynamic_reloc_info)
    bfd_fatal (bfd_get_filename (abfd));

  if (relsize > 0)
    {
      disasm_info.dynrelbuf = (arelent **) xmalloc (relsize);
      disasm_info.dynrelcount
        = bfd_canonicalize_dynamic_reloc (abfd, disasm_info.dynrelbuf, dynsyms);
      if (disasm_info.dynrelcount < 0)
        bfd_fatal (bfd_get_filename (abfd));

      /* Sort the relocs by address.  */
      qsort (disasm_info.dynrelbuf, disasm_info.dynrelcount, sizeof (arelent *),
             compare_relocs);
    }

  disasm_info.symtab = sorted_syms;
  disasm_info.symtab_size = sorted_symcount;

  bfd_map_over_sections (abfd, disassemble_section, & disasm_info);

  free (disasm_info.dynrelbuf);
  disasm_info.dynrelbuf = NULL;
  free (sorted_syms);
  disassemble_free_target (&disasm_info);
}
\f
static bool
load_specific_debug_section (enum dwarf_section_display_enum debug,
                             asection *sec, void *file)
{
  struct dwarf_section *section = &debug_displays [debug].section;
  bfd *abfd = (bfd *) file;
  bfd_byte *contents;
  bfd_size_type amt;
  size_t alloced;
  bool ret;

  if (section->start != NULL)
    {
      /* If it is already loaded, do nothing.  */
      if (streq (section->filename, bfd_get_filename (abfd)))
        return true;
      free (section->start);
    }

  section->filename = bfd_get_filename (abfd);
  section->reloc_info = NULL;
  section->num_relocs = 0;
  section->address = bfd_section_vma (sec);
  section->size = bfd_section_size (sec);
  /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
  alloced = amt = section->size + 1;
  if (alloced != amt || alloced == 0)
    {
      section->start = NULL;
      free_debug_section (debug);
      printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
              sanitize_string (section->name),
              (unsigned long long) section->size);
      return false;
    }

  section->start = contents = xmalloc (alloced);
  /* Ensure any string section has a terminating NUL.  */
  section->start[section->size] = 0;

  if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
      && debug_displays [debug].relocate)
    {
      ret = bfd_simple_get_relocated_section_contents (abfd,
                                                       sec,
                                                       section->start,
                                                       syms) != NULL;
      if (ret)
        {
          long reloc_size = bfd_get_reloc_upper_bound (abfd, sec);

          if (reloc_size > 0)
            {
              unsigned long reloc_count;
              arelent **relocs;

              relocs = (arelent **) xmalloc (reloc_size);

              reloc_count = bfd_canonicalize_reloc (abfd, sec, relocs, NULL);
              if (reloc_count == 0)
                free (relocs);
              else
                {
                  section->reloc_info = relocs;
                  section->num_relocs = reloc_count;
                }
            }
        }
    }
  else
    ret = bfd_get_full_section_contents (abfd, sec, &contents);

  if (!ret)
    {
      free_debug_section (debug);
      printf (_("\nCan't get contents for section '%s'.\n"),
              sanitize_string (section->name));
      return false;
    }

  return true;
}

bool
reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
{
  arelent ** relocs;
  arelent * rp;

  if (dsec == NULL || dsec->reloc_info == NULL)
    return false;

  relocs = (arelent **) dsec->reloc_info;

  for (; (rp = * relocs) != NULL; ++ relocs)
    if (rp->address == offset)
      return true;

  return false;
}

bool
load_debug_section (enum dwarf_section_display_enum debug, void *file)
{
  struct dwarf_section *section = &debug_displays [debug].section;
  bfd *abfd = (bfd *) file;
  asection *sec;
  const char *name;

  if (!dump_any_debugging)
    return false;

  /* If it is already loaded, do nothing.  */
  if (section->start != NULL)
    {
      if (streq (section->filename, bfd_get_filename (abfd)))
        return true;
    }
  /* Locate the debug section.  */
  name = section->uncompressed_name;
  sec = bfd_get_section_by_name (abfd, name);
  if (sec == NULL)
    {
      name = section->compressed_name;
      if (*name)
        sec = bfd_get_section_by_name (abfd, name);
    }
  if (sec == NULL)
    {
      name = section->xcoff_name;
      if (*name)
        sec = bfd_get_section_by_name (abfd, name);
    }
  if (sec == NULL)
    return false;

  section->name = name;
  return load_specific_debug_section (debug, sec, file);
}

void
free_debug_section (enum dwarf_section_display_enum debug)
{
  struct dwarf_section *section = &debug_displays [debug].section;

  free ((char *) section->start);
  section->start = NULL;
  section->address = 0;
  section->size = 0;
}

void
close_debug_file (void * file)
{
  bfd * abfd = (bfd *) file;

  bfd_close (abfd);
}

void *
open_debug_file (const char * pathname)
{
  bfd * data;

  data = bfd_openr (pathname, NULL);
  if (data == NULL)
    return NULL;

  if (! bfd_check_format (data, bfd_object))
    return NULL;

  return data;
}

#if HAVE_LIBDEBUGINFOD
/* Return a hex string represention of the build-id.  */

unsigned char *
get_build_id (void * data)
{
  unsigned i;
  char * build_id_str;
  bfd * abfd = (bfd *) data;
  const struct bfd_build_id * build_id;

  build_id = abfd->build_id;
  if (build_id == NULL)
    return NULL;

  build_id_str = malloc (build_id->size * 2 + 1);
  if (build_id_str == NULL)
    return NULL;

  for (i = 0; i < build_id->size; i++)
    sprintf (build_id_str + (i * 2), "%02x", build_id->data[i]);
  build_id_str[build_id->size * 2] = '\0';

  return (unsigned char *)build_id_str;
}
#endif /* HAVE_LIBDEBUGINFOD */

static void
dump_dwarf_section (bfd *abfd, asection *section,
                    void *arg)
{
  const char *name = bfd_section_name (section);
  const char *match;
  int i;
  bool is_mainfile = *(bool *) arg;

  if (*name == 0)
    return;

  if (!is_mainfile && !process_links
      && (section->flags & SEC_DEBUGGING) == 0)
    return;

  if (startswith (name, ".gnu.linkonce.wi."))
    match = ".debug_info";
  else
    match = name;

  for (i = 0; i < max; i++)
    if ((strcmp (debug_displays [i].section.uncompressed_name, match) == 0
         || strcmp (debug_displays [i].section.compressed_name, match) == 0
         || strcmp (debug_displays [i].section.xcoff_name, match) == 0)
        && debug_displays [i].enabled != NULL
        && *debug_displays [i].enabled)
      {
        struct dwarf_section *sec = &debug_displays [i].section;

        if (strcmp (sec->uncompressed_name, match) == 0)
          sec->name = sec->uncompressed_name;
        else if (strcmp (sec->compressed_name, match) == 0)
          sec->name = sec->compressed_name;
        else
          sec->name = sec->xcoff_name;
        if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
                                         section, abfd))
          {
            debug_displays [i].display (sec, abfd);

            if (i != info && i != abbrev)
              free_debug_section ((enum dwarf_section_display_enum) i);
          }
        break;
      }
}

/* Dump the dwarf debugging information.  */

static void
dump_dwarf (bfd *abfd, bool is_mainfile)
{
  /* The byte_get pointer should have been set at the start of dump_bfd().  */
  if (byte_get == NULL)
    {
      warn (_("File %s does not contain any dwarf debug information\n"),
            bfd_get_filename (abfd));
      return;
    }

  switch (bfd_get_arch (abfd))
    {
    case bfd_arch_s12z:
      /* S12Z has a 24 bit address space.  But the only known
         producer of dwarf_info encodes addresses into 32 bits.  */
      eh_addr_size = 4;
      break;

    default:
      eh_addr_size = bfd_arch_bits_per_address (abfd) / 8;
      break;
    }

  init_dwarf_regnames_by_bfd_arch_and_mach (bfd_get_arch (abfd),
                                            bfd_get_mach (abfd));

  bfd_map_over_sections (abfd, dump_dwarf_section, (void *) &is_mainfile);
}
\f
/* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
   it.  Return NULL on failure.   */

static bfd_byte *
read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr,
                    bfd_size_type *entsize_ptr)
{
  asection *stabsect;
  bfd_byte *contents;

  stabsect = bfd_get_section_by_name (abfd, sect_name);
  if (stabsect == NULL)
    {
      printf (_("No %s section present\n\n"),
              sanitize_string (sect_name));
      return false;
    }

  if (!bfd_malloc_and_get_section (abfd, stabsect, &contents))
    {
      non_fatal (_("reading %s section of %s failed: %s"),
                 sect_name, bfd_get_filename (abfd),
                 bfd_errmsg (bfd_get_error ()));
      exit_status = 1;
      free (contents);
      return NULL;
    }

  *size_ptr = bfd_section_size (stabsect);
  if (entsize_ptr)
    *entsize_ptr = stabsect->entsize;

  return contents;
}

/* Stabs entries use a 12 byte format:
     4 byte string table index
     1 byte stab type
     1 byte stab other field
     2 byte stab desc field
     4 byte stab value
   FIXME: This will have to change for a 64 bit object format.  */

#define STRDXOFF  (0)
#define TYPEOFF   (4)
#define OTHEROFF  (5)
#define DESCOFF   (6)
#define VALOFF    (8)
#define STABSIZE (12)

/* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
   using string table section STRSECT_NAME (in `strtab').  */

static void
print_section_stabs (bfd *abfd,
                     const char *stabsect_name,
                     unsigned *string_offset_ptr)
{
  int i;
  unsigned file_string_table_offset = 0;
  unsigned next_file_string_table_offset = *string_offset_ptr;
  bfd_byte *stabp, *stabs_end;

  stabp = stabs;
  stabs_end = stabp + stab_size;

  printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name));
  printf ("Symnum n_type n_othr n_desc n_value  n_strx String\n");

  /* Loop through all symbols and print them.

     We start the index at -1 because there is a dummy symbol on
     the front of stabs-in-{coff,elf} sections that supplies sizes.  */
  for (i = -1; stabp <= stabs_end - STABSIZE; stabp += STABSIZE, i++)
    {
      const char *name;
      unsigned long strx;
      unsigned char type, other;
      unsigned short desc;
      bfd_vma value;

      strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
      type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
      other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
      desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
      value = bfd_h_get_32 (abfd, stabp + VALOFF);

      printf ("\n%-6d ", i);
      /* Either print the stab name, or, if unnamed, print its number
         again (makes consistent formatting for tools like awk).  */
      name = bfd_get_stab_name (type);
      if (name != NULL)
        printf ("%-6s", sanitize_string (name));
      else if (type == N_UNDF)
        printf ("HdrSym");
      else
        printf ("%-6d", type);
      printf (" %-6d %-6d ", other, desc);
      bfd_printf_vma (abfd, value);
      printf (" %-6lu", strx);

      /* Symbols with type == 0 (N_UNDF) specify the length of the
         string table associated with this file.  We use that info
         to know how to relocate the *next* file's string table indices.  */
      if (type == N_UNDF)
        {
          file_string_table_offset = next_file_string_table_offset;
          next_file_string_table_offset += value;
        }
      else
        {
          bfd_size_type amt = strx + file_string_table_offset;

          /* Using the (possibly updated) string table offset, print the
             string (if any) associated with this symbol.  */
          if (amt < stabstr_size)
            /* PR 17512: file: 079-79389-0.001:0.1.
               FIXME: May need to sanitize this string before displaying.  */
            printf (" %.*s", (int)(stabstr_size - amt), strtab + amt);
          else
            printf (" *");
        }
    }
  printf ("\n\n");
  *string_offset_ptr = next_file_string_table_offset;
}

typedef struct
{
  const char * section_name;
  const char * string_section_name;
  unsigned string_offset;
}
stab_section_names;

static void
find_stabs_section (bfd *abfd, asection *section, void *names)
{
  int len;
  stab_section_names * sought = (stab_section_names *) names;

  /* Check for section names for which stabsect_name is a prefix, to
     handle .stab.N, etc.  */
  len = strlen (sought->section_name);

  /* If the prefix matches, and the files section name ends with a
     nul or a digit, then we match.  I.e., we want either an exact
     match or a section followed by a number.  */
  if (strncmp (sought->section_name, section->name, len) == 0
      && (section->name[len] == 0
          || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
    {
      if (strtab == NULL)
        strtab = read_section_stabs (abfd, sought->string_section_name,
                                     &stabstr_size, NULL);

      if (strtab)
        {
          stabs = read_section_stabs (abfd, section->name, &stab_size, NULL);
          if (stabs)
            print_section_stabs (abfd, section->name, &sought->string_offset);
        }
    }
}

static void
dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
{
  stab_section_names s;

  s.section_name = stabsect_name;
  s.string_section_name = strsect_name;
  s.string_offset = 0;

  bfd_map_over_sections (abfd, find_stabs_section, & s);

  free (strtab);
  strtab = NULL;
}

/* Dump the any sections containing stabs debugging information.  */

static void
dump_stabs (bfd *abfd)
{
  dump_stabs_section (abfd, ".stab", ".stabstr");
  dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
  dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");

  /* For Darwin.  */
  dump_stabs_section (abfd, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");

  dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
}
\f
static void
dump_bfd_header (bfd *abfd)
{
  char *comma = "";

  printf (_("architecture: %s, "),
          bfd_printable_arch_mach (bfd_get_arch (abfd),
                                   bfd_get_mach (abfd)));
  printf (_("flags 0x%08x:\n"), abfd->flags & ~BFD_FLAGS_FOR_BFD_USE_MASK);

#define PF(x, y)    if (abfd->flags & x) {printf ("%s%s", comma, y); comma=", ";}
  PF (HAS_RELOC, "HAS_RELOC");
  PF (EXEC_P, "EXEC_P");
  PF (HAS_LINENO, "HAS_LINENO");
  PF (HAS_DEBUG, "HAS_DEBUG");
  PF (HAS_SYMS, "HAS_SYMS");
  PF (HAS_LOCALS, "HAS_LOCALS");
  PF (DYNAMIC, "DYNAMIC");
  PF (WP_TEXT, "WP_TEXT");
  PF (D_PAGED, "D_PAGED");
  PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
  printf (_("\nstart address 0x"));
  bfd_printf_vma (abfd, abfd->start_address);
  printf ("\n");
}
\f

#ifdef ENABLE_LIBCTF
/* Formatting callback function passed to ctf_dump.  Returns either the pointer
   it is passed, or a pointer to newly-allocated storage, in which case
   dump_ctf() will free it when it no longer needs it.  */

static char *
dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED,
                       char *s, void *arg)
{
  const char *blanks = arg;
  char *new_s;

  if (asprintf (&new_s, "%s%s", blanks, s) < 0)
    return s;
  return new_s;
}

/* Make a ctfsect suitable for ctf_bfdopen_ctfsect().  */
static ctf_sect_t
make_ctfsect (const char *name, bfd_byte *data,
              bfd_size_type size)
{
  ctf_sect_t ctfsect;

  ctfsect.cts_name = name;
  ctfsect.cts_entsize = 1;
  ctfsect.cts_size = size;
  ctfsect.cts_data = data;

  return ctfsect;
}

/* Dump CTF errors/warnings.  */
static void
dump_ctf_errs (ctf_dict_t *fp)
{
  ctf_next_t *it = NULL;
  char *errtext;
  int is_warning;
  int err;

  /* Dump accumulated errors and warnings.  */
  while ((errtext = ctf_errwarning_next (fp, &it, &is_warning, &err)) != NULL)
    {
      non_fatal (_("%s: %s"), is_warning ? _("warning"): _("error"),
                 errtext);
      free (errtext);
    }
  if (err != ECTF_NEXT_END)
    {
      non_fatal (_("CTF error: cannot get CTF errors: `%s'"),
                 ctf_errmsg (err));
    }
}

/* Dump one CTF archive member.  */

static void
dump_ctf_archive_member (ctf_dict_t *ctf, const char *name, ctf_dict_t *parent,
                         size_t member)
{
  const char *things[] = {"Header", "Labels", "Data objects",
                          "Function objects", "Variables", "Types", "Strings",
                          ""};
  const char **thing;
  size_t i;

  /* Don't print out the name of the default-named archive member if it appears
     first in the list.  The name .ctf appears everywhere, even for things that
     aren't really archives, so printing it out is liable to be confusing; also,
     the common case by far is for only one archive member to exist, and hiding
     it in that case seems worthwhile.  */

  if (strcmp (name, ".ctf") != 0 || member != 0)
    printf (_("\nCTF archive member: %s:\n"), sanitize_string (name));

  if (ctf_parent_name (ctf) != NULL)
    ctf_import (ctf, parent);

  for (i = 0, thing = things; *thing[0]; thing++, i++)
    {
      ctf_dump_state_t *s = NULL;
      char *item;

      printf ("\n  %s:\n", *thing);
      while ((item = ctf_dump (ctf, &s, i, dump_ctf_indent_lines,
                               (void *) "    ")) != NULL)
        {
          printf ("%s\n", item);
          free (item);
        }

      if (ctf_errno (ctf))
        {
          non_fatal (_("Iteration failed: %s, %s"), *thing,
                   ctf_errmsg (ctf_errno (ctf)));
          break;
        }
    }

  dump_ctf_errs (ctf);
}

/* Dump the CTF debugging information.  */

static void
dump_ctf (bfd *abfd, const char *sect_name, const char *parent_name)
{
  ctf_archive_t *ctfa = NULL;
  bfd_byte *ctfdata = NULL;
  bfd_size_type ctfsize;
  ctf_sect_t ctfsect;
  ctf_dict_t *parent;
  ctf_dict_t *fp;
  ctf_next_t *i = NULL;
  const char *name;
  size_t member = 0;
  int err;

  if (sect_name == NULL)
    sect_name = ".ctf";

  if ((ctfdata = read_section_stabs (abfd, sect_name, &ctfsize, NULL)) == NULL)
      bfd_fatal (bfd_get_filename (abfd));

  /* Load the CTF file and dump it.  Preload the parent dict, since it will
     need to be imported into every child in turn. */

  ctfsect = make_ctfsect (sect_name, ctfdata, ctfsize);
  if ((ctfa = ctf_bfdopen_ctfsect (abfd, &ctfsect, &err)) == NULL)
    {
      dump_ctf_errs (NULL);
      non_fatal (_("CTF open failure: %s"), ctf_errmsg (err));
      bfd_fatal (bfd_get_filename (abfd));
    }

  if ((parent = ctf_dict_open (ctfa, parent_name, &err)) == NULL)
    {
      dump_ctf_errs (NULL);
      non_fatal (_("CTF open failure: %s"), ctf_errmsg (err));
      bfd_fatal (bfd_get_filename (abfd));
    }

  printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name));

  while ((fp = ctf_archive_next (ctfa, &i, &name, 0, &err)) != NULL)
    dump_ctf_archive_member (fp, name, parent, member++);
  if (err != ECTF_NEXT_END)
    {
      dump_ctf_errs (NULL);
      non_fatal (_("CTF archive member open failure: %s"), ctf_errmsg (err));
      bfd_fatal (bfd_get_filename (abfd));
    }
  ctf_dict_close (parent);
  ctf_close (ctfa);
  free (ctfdata);
}
#else
static void
dump_ctf (bfd *abfd ATTRIBUTE_UNUSED, const char *sect_name ATTRIBUTE_UNUSED,
          const char *parent_name ATTRIBUTE_UNUSED) {}
#endif

\f
static void
dump_bfd_private_header (bfd *abfd)
{
  if (!bfd_print_private_bfd_data (abfd, stdout))
    non_fatal (_("warning: private headers incomplete: %s"),
               bfd_errmsg (bfd_get_error ()));
}

static void
dump_target_specific (bfd *abfd)
{
  const struct objdump_private_desc * const *desc;
  struct objdump_private_option *opt;
  char *e, *b;

  /* Find the desc.  */
  for (desc = objdump_private_vectors; *desc != NULL; desc++)
    if ((*desc)->filter (abfd))
      break;

  if (*desc == NULL)
    {
      non_fatal (_("option -P/--private not supported by this file"));
      return;
    }

  /* Clear all options.  */
  for (opt = (*desc)->options; opt->name; opt++)
    opt->selected = false;

  /* Decode options.  */
  b = dump_private_options;
  do
    {
      e = strchr (b, ',');

      if (e)
        *e = 0;

      for (opt = (*desc)->options; opt->name; opt++)
        if (strcmp (opt->name, b) == 0)
          {
            opt->selected = true;
            break;
          }
      if (opt->name == NULL)
        non_fatal (_("target specific dump '%s' not supported"), b);

      if (e)
        {
          *e = ',';
          b = e + 1;
        }
    }
  while (e != NULL);

  /* Dump.  */
  (*desc)->dump (abfd);
}
\f
/* Display a section in hexadecimal format with associated characters.
   Each line prefixed by the zero padded address.  */

static void
dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
{
  bfd_byte *data = NULL;
  bfd_size_type datasize;
  bfd_vma addr_offset;
  bfd_vma start_offset;
  bfd_vma stop_offset;
  unsigned int opb = bfd_octets_per_byte (abfd, section);
  /* Bytes per line.  */
  const int onaline = 16;
  char buf[64];
  int count;
  int width;

  if (! process_section_p (section))
    return;

  if ((section->flags & SEC_HAS_CONTENTS) == 0)
    return;

  if ((datasize = bfd_section_size (section)) == 0)
    return;

  /* Compute the address range to display.  */
  if (start_address == (bfd_vma) -1
      || start_address < section->vma)
    start_offset = 0;
  else
    start_offset = start_address - section->vma;

  if (stop_address == (bfd_vma) -1)
    stop_offset = datasize / opb;
  else
    {
      if (stop_address < section->vma)
        stop_offset = 0;
      else
        stop_offset = stop_address - section->vma;

      if (stop_offset > datasize / opb)
        stop_offset = datasize / opb;
    }

  if (start_offset >= stop_offset)
    return;

  printf (_("Contents of section %s:"), sanitize_string (section->name));
  if (display_file_offsets)
    printf (_("  (Starting at file offset: 0x%lx)"),
            (unsigned long) (section->filepos + start_offset));
  printf ("\n");

  if (!bfd_get_full_section_contents (abfd, section, &data))
    {
      non_fatal (_("Reading section %s failed because: %s"),
                 section->name, bfd_errmsg (bfd_get_error ()));
      return;
    }

  width = 4;

  bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
  if (strlen (buf) >= sizeof (buf))
    abort ();

  count = 0;
  while (buf[count] == '0' && buf[count+1] != '\0')
    count++;
  count = strlen (buf) - count;
  if (count > width)
    width = count;

  bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
  if (strlen (buf) >= sizeof (buf))
    abort ();

  count = 0;
  while (buf[count] == '0' && buf[count+1] != '\0')
    count++;
  count = strlen (buf) - count;
  if (count > width)
    width = count;

  for (addr_offset = start_offset;
       addr_offset < stop_offset; addr_offset += onaline / opb)
    {
      bfd_size_type j;

      bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
      count = strlen (buf);
      if ((size_t) count >= sizeof (buf))
        abort ();

      putchar (' ');
      while (count < width)
        {
          putchar ('0');
          count++;
        }
      fputs (buf + count - width, stdout);
      putchar (' ');

      for (j = addr_offset * opb;
           j < addr_offset * opb + onaline; j++)
        {
          if (j < stop_offset * opb)
            printf ("%02x", (unsigned) (data[j]));
          else
            printf ("  ");
          if ((j & 3) == 3)
            printf (" ");
        }

      printf (" ");
      for (j = addr_offset * opb;
           j < addr_offset * opb + onaline; j++)
        {
          if (j >= stop_offset * opb)
            printf (" ");
          else
            printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
        }
      putchar ('\n');
    }
  free (data);
}

/* Actually display the various requested regions.  */

static void
dump_data (bfd *abfd)
{
  bfd_map_over_sections (abfd, dump_section, NULL);
}

/* Should perhaps share code and display with nm?  */

static void
dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bool dynamic)
{
  asymbol **current;
  long max_count;
  long count;

  if (dynamic)
    {
      current = dynsyms;
      max_count = dynsymcount;
      printf ("DYNAMIC SYMBOL TABLE:\n");
    }
  else
    {
      current = syms;
      max_count = symcount;
      printf ("SYMBOL TABLE:\n");
    }

  if (max_count == 0)
    printf (_("no symbols\n"));

  for (count = 0; count < max_count; count++)
    {
      bfd *cur_bfd;

      if (*current == NULL)
        printf (_("no information for symbol number %ld\n"), count);

      else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
        printf (_("could not determine the type of symbol number %ld\n"),
                count);

      else if (process_section_p ((* current)->section)
               && (dump_special_syms
                   || !bfd_is_target_special_symbol (cur_bfd, *current)))
        {
          const char *name = (*current)->name;

          if (do_demangle && name != NULL && *name != '\0')
            {
              char *alloc;

              /* If we want to demangle the name, we demangle it
                 here, and temporarily clobber it while calling
                 bfd_print_symbol.  FIXME: This is a gross hack.  */
              alloc = bfd_demangle (cur_bfd, name, demangle_flags);
              if (alloc != NULL)
                (*current)->name = alloc;
              bfd_print_symbol (cur_bfd, stdout, *current,
                                bfd_print_symbol_all);
              if (alloc != NULL)
                {
                  (*current)->name = name;
                  free (alloc);
                }
            }
          else if (unicode_display != unicode_default
                   && name != NULL && *name != '\0')
            {
              const char * sanitized_name;

              /* If we want to sanitize the name, we do it here, and
                 temporarily clobber it while calling bfd_print_symbol.
                 FIXME: This is a gross hack.  */
              sanitized_name = sanitize_string (name);
              if (sanitized_name != name)
                (*current)->name = sanitized_name;
              else
                sanitized_name = NULL;
              bfd_print_symbol (cur_bfd, stdout, *current,
                                bfd_print_symbol_all);
              if (sanitized_name != NULL)
                (*current)->name = name;
            }
          else
            bfd_print_symbol (cur_bfd, stdout, *current,
                              bfd_print_symbol_all);
          printf ("\n");
        }

      current++;
    }
  printf ("\n\n");
}
\f
static void
dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
{
  arelent **p;
  char *last_filename, *last_functionname;
  unsigned int last_line;
  unsigned int last_discriminator;

  /* Get column headers lined up reasonably.  */
  {
    static int width;

    if (width == 0)
      {
        char buf[30];

        bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
        width = strlen (buf) - 7;
      }
    printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
  }

  last_filename = NULL;
  last_functionname = NULL;
  last_line = 0;
  last_discriminator = 0;

  for (p = relpp; relcount && *p != NULL; p++, relcount--)
    {
      arelent *q = *p;
      const char *filename, *functionname;
      unsigned int linenumber;
      unsigned int discriminator;
      const char *sym_name;
      const char *section_name;
      bfd_vma addend2 = 0;

      if (start_address != (bfd_vma) -1
          && q->address < start_address)
        continue;
      if (stop_address != (bfd_vma) -1
          && q->address > stop_address)
        continue;

      if (with_line_numbers
          && sec != NULL
          && bfd_find_nearest_line_discriminator (abfd, sec, syms, q->address,
                                                  &filename, &functionname,
                                                  &linenumber, &discriminator))
        {
          if (functionname != NULL
              && (last_functionname == NULL
                  || strcmp (functionname, last_functionname) != 0))
            {
              printf ("%s():\n", sanitize_string (functionname));
              if (last_functionname != NULL)
                free (last_functionname);
              last_functionname = xstrdup (functionname);
            }

          if (linenumber > 0
              && (linenumber != last_line
                  || (filename != NULL
                      && last_filename != NULL
                      && filename_cmp (filename, last_filename) != 0)
                  || (discriminator != last_discriminator)))
            {
              if (discriminator > 0)
                printf ("%s:%u\n", filename == NULL ? "???" :
                        sanitize_string (filename), linenumber);
              else
                printf ("%s:%u (discriminator %u)\n",
                        filename == NULL ? "???" : sanitize_string (filename),
                        linenumber, discriminator);
              last_line = linenumber;
              last_discriminator = discriminator;
              if (last_filename != NULL)
                free (last_filename);
              if (filename == NULL)
                last_filename = NULL;
              else
                last_filename = xstrdup (filename);
            }
        }

      if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
        {
          sym_name = (*(q->sym_ptr_ptr))->name;
          section_name = (*(q->sym_ptr_ptr))->section->name;
        }
      else
        {
          sym_name = NULL;
          section_name = NULL;
        }

      bfd_printf_vma (abfd, q->address);
      if (q->howto == NULL)
        printf (" *unknown*         ");
      else if (q->howto->name)
        {
          const char *name = q->howto->name;

          /* R_SPARC_OLO10 relocations contain two addends.
             But because 'arelent' lacks enough storage to
             store them both, the 64-bit ELF Sparc backend
             records this as two relocations.  One R_SPARC_LO10
             and one R_SPARC_13, both pointing to the same
             address.  This is merely so that we have some
             place to store both addend fields.

             Undo this transformation, otherwise the output
             will be confusing.  */
          if (abfd->xvec->flavour == bfd_target_elf_flavour
              && elf_tdata (abfd)->elf_header->e_machine == EM_SPARCV9
              && relcount > 1
              && !strcmp (q->howto->name, "R_SPARC_LO10"))
            {
              arelent *q2 = *(p + 1);
              if (q2 != NULL
                  && q2->howto
                  && q->address == q2->address
                  && !strcmp (q2->howto->name, "R_SPARC_13"))
                {
                  name = "R_SPARC_OLO10";
                  addend2 = q2->addend;
                  p++;
                }
            }
          printf (" %-16s  ", name);
        }
      else
        printf (" %-16d  ", q->howto->type);

      if (sym_name)
        {
          objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
        }
      else
        {
          if (section_name == NULL)
            section_name = "*unknown*";
          printf ("[%s]", sanitize_string (section_name));
        }

      if (q->addend)
        {
          bfd_signed_vma addend = q->addend;
          if (addend < 0)
            {
              printf ("-0x");
              addend = -addend;
            }
          else
            printf ("+0x");
          bfd_printf_vma (abfd, addend);
        }
      if (addend2)
        {
          printf ("+0x");
          bfd_printf_vma (abfd, addend2);
        }

      printf ("\n");
    }

  if (last_filename != NULL)
    free (last_filename);
  if (last_functionname != NULL)
    free (last_functionname);
}

static void
dump_relocs_in_section (bfd *abfd,
                        asection *section,
                        void *dummy ATTRIBUTE_UNUSED)
{
  arelent **relpp = NULL;
  long relcount;
  long relsize;

  if (   bfd_is_abs_section (section)
      || bfd_is_und_section (section)
      || bfd_is_com_section (section)
      || (! process_section_p (section))
      || ((section->flags & SEC_RELOC) == 0))
    return;

  printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section->name));

  relsize = bfd_get_reloc_upper_bound (abfd, section);
  if (relsize == 0)
    {
      printf (" (none)\n\n");
      return;
    }

  if (relsize < 0)
    relcount = relsize;
  else
    {
      relpp = (arelent **) xmalloc (relsize);
      relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
    }

  if (relcount < 0)
    {
      printf ("\n");
      non_fatal (_("failed to read relocs in: %s"),
                 sanitize_string (bfd_get_filename (abfd)));
      bfd_fatal (_("error message was"));
    }
  else if (relcount == 0)
    printf (" (none)\n\n");
  else
    {
      printf ("\n");
      dump_reloc_set (abfd, section, relpp, relcount);
      printf ("\n\n");
    }
  free (relpp);
}

static void
dump_relocs (bfd *abfd)
{
  bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
}

static void
dump_dynamic_relocs (bfd *abfd)
{
  long relsize;
  arelent **relpp;
  long relcount;

  relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
  if (relsize < 0)
    bfd_fatal (bfd_get_filename (abfd));

  printf ("DYNAMIC RELOCATION RECORDS");

  if (relsize == 0)
    printf (" (none)\n\n");
  else
    {
      relpp = (arelent **) xmalloc (relsize);
      relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);

      if (relcount < 0)
        bfd_fatal (bfd_get_filename (abfd));
      else if (relcount == 0)
        printf (" (none)\n\n");
      else
        {
          printf ("\n");
          dump_reloc_set (abfd, NULL, relpp, relcount);
          printf ("\n\n");
        }
      free (relpp);
    }
}

/* Creates a table of paths, to search for source files.  */

static void
add_include_path (const char *path)
{
  if (path[0] == 0)
    return;
  include_path_count++;
  include_paths = (const char **)
      xrealloc (include_paths, include_path_count * sizeof (*include_paths));
#ifdef HAVE_DOS_BASED_FILE_SYSTEM
  if (path[1] == ':' && path[2] == 0)
    path = concat (path, ".", (const char *) 0);
#endif
  include_paths[include_path_count - 1] = path;
}

static void
adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
                  asection *section,
                  void *arg)
{
  if ((section->flags & SEC_DEBUGGING) == 0)
    {
      bool *has_reloc_p = (bool *) arg;
      section->vma += adjust_section_vma;
      if (*has_reloc_p)
        section->lma += adjust_section_vma;
    }
}

/* Return the sign-extended form of an ARCH_SIZE sized VMA.  */

static bfd_vma
sign_extend_address (bfd *abfd ATTRIBUTE_UNUSED,
                     bfd_vma vma,
                     unsigned arch_size)
{
  bfd_vma mask;
  mask = (bfd_vma) 1 << (arch_size - 1);
  return (((vma & ((mask << 1) - 1)) ^ mask) - mask);
}

/* Dump selected contents of ABFD.  */

static void
dump_bfd (bfd *abfd, bool is_mainfile)
{
  const struct elf_backend_data * bed;

  if (bfd_big_endian (abfd))
    byte_get = byte_get_big_endian;
  else if (bfd_little_endian (abfd))
    byte_get = byte_get_little_endian;
  else
    byte_get = NULL;

  /* Load any separate debug information files.
     We do this now and without checking do_follow_links because separate
     debug info files may contain symbol tables that we will need when
     displaying information about the main file.  Any memory allocated by
     load_separate_debug_files will be released when we call
     free_debug_memory below.

     The test on is_mainfile is there because the chain of separate debug
     info files is a global variable shared by all invocations of dump_bfd.  */
  if (byte_get != NULL && is_mainfile)
    {
      load_separate_debug_files (abfd, bfd_get_filename (abfd));

      /* If asked to do so, recursively dump the separate files.  */
      if (do_follow_links)
        {
          separate_info * i;

          for (i = first_separate_info; i != NULL; i = i->next)
            dump_bfd (i->handle, false);
        }
    }

  /* Adjust user-specified start and stop limits for targets that use
     signed addresses.  */
  if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
      && (bed = get_elf_backend_data (abfd)) != NULL
      && bed->sign_extend_vma)
    {
      start_address = sign_extend_address (abfd, start_address,
                                           bed->s->arch_size);
      stop_address = sign_extend_address (abfd, stop_address,
                                          bed->s->arch_size);
    }

  /* If we are adjusting section VMA's, change them all now.  Changing
     the BFD information is a hack.  However, we must do it, or
     bfd_find_nearest_line will not do the right thing.  */
  if (adjust_section_vma != 0)
    {
      bool has_reloc = (abfd->flags & HAS_RELOC);
      bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
    }

  if (is_mainfile || process_links)
    {
      if (! dump_debugging_tags && ! suppress_bfd_header)
        printf (_("\n%s:     file format %s\n"),
                sanitize_string (bfd_get_filename (abfd)),
                abfd->xvec->name);
      if (dump_ar_hdrs)
        print_arelt_descr (stdout, abfd, true, false);
      if (dump_file_header)
        dump_bfd_header (abfd);
      if (dump_private_headers)
        dump_bfd_private_header (abfd);
      if (dump_private_options != NULL)
        dump_target_specific (abfd);
      if (! dump_debugging_tags && ! suppress_bfd_header)
        putchar ('\n');
    }

  if (dump_symtab
      || dump_reloc_info
      || disassemble
      || dump_debugging
      || dump_dwarf_section_info)
    {
      syms = slurp_symtab (abfd);

      /* If following links, load any symbol tables from the linked files as well.  */
      if (do_follow_links && is_mainfile)
        {
          separate_info * i;

          for (i = first_separate_info; i != NULL; i = i->next)
            {
              asymbol **  extra_syms;
              long        old_symcount = symcount;

              extra_syms = slurp_symtab (i->handle);

              if (extra_syms)
                {
                  if (old_symcount == 0)
                    {
                      syms = extra_syms;
                    }
                  else
                    {
                      syms = xrealloc (syms, ((symcount + old_symcount + 1)
                                              * sizeof (asymbol *)));
                      memcpy (syms + old_symcount,
                              extra_syms,
                              (symcount + 1) * sizeof (asymbol *));
                    }
                }

              symcount += old_symcount;
            }
        }
    }

  if (is_mainfile || process_links)
    {
      if (dump_section_headers)
        dump_headers (abfd);

      if (dump_dynamic_symtab || dump_dynamic_reloc_info
          || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
        dynsyms = slurp_dynamic_symtab (abfd);

      if (disassemble)
        {
          synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
                                                 dynsymcount, dynsyms,
                                                 &synthsyms);
          if (synthcount < 0)
            synthcount = 0;
        }

      if (dump_symtab)
        dump_symbols (abfd, false);
      if (dump_dynamic_symtab)
        dump_symbols (abfd, true);
    }
  if (dump_dwarf_section_info)
    dump_dwarf (abfd, is_mainfile);
  if (is_mainfile || process_links)
    {
      if (dump_ctf_section_info)
        dump_ctf (abfd, dump_ctf_section_name, dump_ctf_parent_name);
      if (dump_stab_section_info)
        dump_stabs (abfd);
      if (dump_reloc_info && ! disassemble)
        dump_relocs (abfd);
      if (dump_dynamic_reloc_info && ! disassemble)
        dump_dynamic_relocs (abfd);
      if (dump_section_contents)
        dump_data (abfd);
      if (disassemble)
        disassemble_data (abfd);
    }

  if (dump_debugging)
    {
      void *dhandle;

      dhandle = read_debugging_info (abfd, syms, symcount, true);
      if (dhandle != NULL)
        {
          if (!print_debugging_info (stdout, dhandle, abfd, syms,
                                     bfd_demangle,
                                     dump_debugging_tags != 0))
            {
              non_fatal (_("%s: printing debugging information failed"),
                         bfd_get_filename (abfd));
              exit_status = 1;
            }

          free (dhandle);
        }
      /* PR 6483: If there was no STABS debug info in the file, try
         DWARF instead.  */
      else if (! dump_dwarf_section_info)
        {
          dwarf_select_sections_all ();
          dump_dwarf (abfd, is_mainfile);
        }
    }

  if (syms)
    {
      free (syms);
      syms = NULL;
    }

  if (dynsyms)
    {
      free (dynsyms);
      dynsyms = NULL;
    }

  if (synthsyms)
    {
      free (synthsyms);
      synthsyms = NULL;
    }

  symcount = 0;
  dynsymcount = 0;
  synthcount = 0;

  if (is_mainfile)
    free_debug_memory ();
}

static void
display_object_bfd (bfd *abfd)
{
  char **matching;

  if (bfd_check_format_matches (abfd, bfd_object, &matching))
    {
      dump_bfd (abfd, true);
      return;
    }

  if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
    {
      nonfatal (bfd_get_filename (abfd));
      list_matching_formats (matching);
      free (matching);
      return;
    }

  if (bfd_get_error () != bfd_error_file_not_recognized)
    {
      nonfatal (bfd_get_filename (abfd));
      return;
    }

  if (bfd_check_format_matches (abfd, bfd_core, &matching))
    {
      dump_bfd (abfd, true);
      return;
    }

  nonfatal (bfd_get_filename (abfd));

  if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
    {
      list_matching_formats (matching);
      free (matching);
    }
}

static void
display_any_bfd (bfd *file, int level)
{
  /* Decompress sections unless dumping the section contents.  */
  if (!dump_section_contents)
    file->flags |= BFD_DECOMPRESS;

  /* If the file is an archive, process all of its elements.  */
  if (bfd_check_format (file, bfd_archive))
    {
      bfd *arfile = NULL;
      bfd *last_arfile = NULL;

      if (level == 0)
        printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file)));
      else if (level > 100)
        {
          /* Prevent corrupted files from spinning us into an
             infinite loop.  100 is an arbitrary heuristic.  */
          fatal (_("Archive nesting is too deep"));
          return;
        }
      else
        printf (_("In nested archive %s:\n"),
                sanitize_string (bfd_get_filename (file)));

      for (;;)
        {
          bfd_set_error (bfd_error_no_error);

          arfile = bfd_openr_next_archived_file (file, arfile);
          if (arfile == NULL)
            {
              if (bfd_get_error () != bfd_error_no_more_archived_files)
                nonfatal (bfd_get_filename (file));
              break;
            }

          display_any_bfd (arfile, level + 1);

          if (last_arfile != NULL)
            {
              bfd_close (last_arfile);
              /* PR 17512: file: ac585d01.  */
              if (arfile == last_arfile)
                {
                  last_arfile = NULL;
                  break;
                }
            }
          last_arfile = arfile;
        }

      if (last_arfile != NULL)
        bfd_close (last_arfile);
    }
  else
    display_object_bfd (file);
}

static void
display_file (char *filename, char *target, bool last_file)
{
  bfd *file;

  if (get_file_size (filename) < 1)
    {
      exit_status = 1;
      return;
    }

  file = bfd_openr (filename, target);
  if (file == NULL)
    {
      nonfatal (filename);
      return;
    }

  display_any_bfd (file, 0);

  /* This is an optimization to improve the speed of objdump, especially when
     dumping a file with lots of associated debug informatiom.  Calling
     bfd_close on such a file can take a non-trivial amount of time as there
     are lots of lists to walk and buffers to free.  This is only really
     necessary however if we are about to load another file and we need the
     memory back.  Otherwise, if we are about to exit, then we can save (a lot
     of) time by only doing a quick close, and allowing the OS to reclaim the
     memory for us.  */
  if (! last_file)
    bfd_close (file);
  else
    bfd_close_all_done (file);
}
\f
int
main (int argc, char **argv)
{
  int c;
  char *target = default_target;
  bool seenflag = false;

#ifdef HAVE_LC_MESSAGES
  setlocale (LC_MESSAGES, "");
#endif
  setlocale (LC_CTYPE, "");

  bindtextdomain (PACKAGE, LOCALEDIR);
  textdomain (PACKAGE);

  program_name = *argv;
  xmalloc_set_program_name (program_name);
  bfd_set_error_program_name (program_name);

  START_PROGRESS (program_name, 0);

  expandargv (&argc, &argv);

  if (bfd_init () != BFD_INIT_MAGIC)
    fatal (_("fatal error: libbfd ABI mismatch"));
  set_default_bfd_target ();

  while ((c = getopt_long (argc, argv,
                           "CDE:FGHI:LM:P:RSTU:VW::ab:defghij:lm:prstvwxz",
                           long_options, (int *) 0))
         != EOF)
    {
      switch (c)
        {
        case 0:
          break;                /* We've been given a long option.  */
        case 'm':
          machine = optarg;
          break;
        case 'M':
          {
            char *options;
            if (disassembler_options)
              /* Ignore potential memory leak for now.  */
              options = concat (disassembler_options, ",",
                                optarg, (const char *) NULL);
            else
              options = optarg;
            disassembler_options = remove_whitespace_and_extra_commas (options);
          }
          break;
        case 'j':
          add_only (optarg);
          break;
        case 'F':
          display_file_offsets = true;
          break;
        case 'l':
          with_line_numbers = true;
          break;
        case 'b':
          target = optarg;
          break;
        case 'C':
          do_demangle = true;
          if (optarg != NULL)
            {
              enum demangling_styles style;

              style = cplus_demangle_name_to_style (optarg);
              if (style == unknown_demangling)
                fatal (_("unknown demangling style `%s'"),
                       optarg);

              cplus_demangle_set_style (style);
            }
          break;
        case OPTION_RECURSE_LIMIT:
          demangle_flags &= ~ DMGL_NO_RECURSE_LIMIT;
          break;
        case OPTION_NO_RECURSE_LIMIT:
          demangle_flags |= DMGL_NO_RECURSE_LIMIT;
          break;
        case 'w':
          do_wide = wide_output = true;
          break;
        case OPTION_ADJUST_VMA:
          adjust_section_vma = parse_vma (optarg, "--adjust-vma");
          break;
        case OPTION_START_ADDRESS:
          start_address = parse_vma (optarg, "--start-address");
          if ((stop_address != (bfd_vma) -1) && stop_address <= start_address)
            fatal (_("error: the start address should be before the end address"));
          break;
        case OPTION_STOP_ADDRESS:
          stop_address = parse_vma (optarg, "--stop-address");
          if ((start_address != (bfd_vma) -1) && stop_address <= start_address)
            fatal (_("error: the stop address should be after the start address"));
          break;
        case OPTION_PREFIX:
          prefix = optarg;
          prefix_length = strlen (prefix);
          /* Remove an unnecessary trailing '/' */
          while (IS_DIR_SEPARATOR (prefix[prefix_length - 1]))
            prefix_length--;
          break;
        case OPTION_PREFIX_STRIP:
          prefix_strip = atoi (optarg);
          if (prefix_strip < 0)
            fatal (_("error: prefix strip must be non-negative"));
          break;
        case OPTION_INSN_WIDTH:
          insn_width = strtoul (optarg, NULL, 0);
          if (insn_width <= 0)
            fatal (_("error: instruction width must be positive"));
          break;
        case OPTION_INLINES:
          unwind_inlines = true;
          break;
        case OPTION_VISUALIZE_JUMPS:
          visualize_jumps = true;
          color_output = false;
          extended_color_output = false;
          if (optarg != NULL)
            {
              if (streq (optarg, "color"))
                color_output = true;
              else if (streq (optarg, "extended-color"))
                {
                  color_output = true;
                  extended_color_output = true;
                }
              else if (streq (optarg, "off"))
                visualize_jumps = false;
              else
                nonfatal (_("unrecognized argument to --visualize-option"));
            }
          break;
        case 'E':
          if (strcmp (optarg, "B") == 0)
            endian = BFD_ENDIAN_BIG;
          else if (strcmp (optarg, "L") == 0)
            endian = BFD_ENDIAN_LITTLE;
          else
            {
              nonfatal (_("unrecognized -E option"));
              usage (stderr, 1);
            }
          break;
        case OPTION_ENDIAN:
          if (strncmp (optarg, "big", strlen (optarg)) == 0)
            endian = BFD_ENDIAN_BIG;
          else if (strncmp (optarg, "little", strlen (optarg)) == 0)
            endian = BFD_ENDIAN_LITTLE;
          else
            {
              non_fatal (_("unrecognized --endian type `%s'"), optarg);
              exit_status = 1;
              usage (stderr, 1);
            }
          break;

        case 'f':
          dump_file_header = true;
          seenflag = true;
          break;
        case 'i':
          formats_info = true;
          seenflag = true;
          break;
        case 'I':
          add_include_path (optarg);
          break;
        case 'p':
          dump_private_headers = true;
          seenflag = true;
          break;
        case 'P':
          dump_private_options = optarg;
          seenflag = true;
          break;
        case 'x':
          dump_private_headers = true;
          dump_symtab = true;
          dump_reloc_info = true;
          dump_file_header = true;
          dump_ar_hdrs = true;
          dump_section_headers = true;
          seenflag = true;
          break;
        case 't':
          dump_symtab = true;
          seenflag = true;
          break;
        case 'T':
          dump_dynamic_symtab = true;
          seenflag = true;
          break;
        case 'd':
          disassemble = true;
          seenflag = true;
          disasm_sym = optarg;
          break;
        case 'z':
          disassemble_zeroes = true;
          break;
        case 'D':
          disassemble = true;
          disassemble_all = true;
          seenflag = true;
          break;
        case 'S':
          disassemble = true;
          with_source_code = true;
          seenflag = true;
          break;
        case OPTION_SOURCE_COMMENT:
          disassemble = true;
          with_source_code = true;
          seenflag = true;
          if (optarg)
            source_comment = xstrdup (sanitize_string (optarg));
          else
            source_comment = xstrdup ("# ");
          break;
        case 'g':
          dump_debugging = 1;
          seenflag = true;
          break;
        case 'e':
          dump_debugging = 1;
          dump_debugging_tags = 1;
          do_demangle = true;
          seenflag = true;
          break;
        case 'L':
          process_links = true;
          do_follow_links = true;
          break;
        case 'W':
          dump_dwarf_section_info = true;
          seenflag = true;
          if (optarg)
            dwarf_select_sections_by_letters (optarg);
          else
            dwarf_select_sections_all ();
          break;
        case OPTION_DWARF:
          dump_dwarf_section_info = true;
          seenflag = true;
          if (optarg)
            dwarf_select_sections_by_names (optarg);
          else
            dwarf_select_sections_all ();
          break;
        case OPTION_DWARF_DEPTH:
          {
            char *cp;
            dwarf_cutoff_level = strtoul (optarg, & cp, 0);
          }
          break;
        case OPTION_DWARF_START:
          {
            char *cp;
            dwarf_start_die = strtoul (optarg, & cp, 0);
            suppress_bfd_header = 1;
          }
          break;
        case OPTION_DWARF_CHECK:
          dwarf_check = true;
          break;
#ifdef ENABLE_LIBCTF
        case OPTION_CTF:
          dump_ctf_section_info = true;
          if (optarg)
            dump_ctf_section_name = xstrdup (optarg);
          seenflag = true;
          break;
        case OPTION_CTF_PARENT:
          dump_ctf_parent_name = xstrdup (optarg);
          break;
#endif
        case 'G':
          dump_stab_section_info = true;
          seenflag = true;
          break;
        case 's':
          dump_section_contents = true;
          seenflag = true;
          break;
        case 'r':
          dump_reloc_info = true;
          seenflag = true;
          break;
        case 'R':
          dump_dynamic_reloc_info = true;
          seenflag = true;
          break;
        case 'a':
          dump_ar_hdrs = true;
          seenflag = true;
          break;
        case 'h':
          dump_section_headers = true;
          seenflag = true;
          break;
        case 'v':
        case 'V':
          show_version = true;
          seenflag = true;
          break;

        case 'U':
          if (streq (optarg, "default") || streq (optarg, "d"))
            unicode_display = unicode_default;
          else if (streq (optarg, "locale") || streq (optarg, "l"))
            unicode_display = unicode_locale;
          else if (streq (optarg, "escape") || streq (optarg, "e"))
            unicode_display = unicode_escape;
          else if (streq (optarg, "invalid") || streq (optarg, "i"))
            unicode_display = unicode_invalid;
          else if (streq (optarg, "hex") || streq (optarg, "x"))
            unicode_display = unicode_hex;
          else if (streq (optarg, "highlight") || streq (optarg, "h"))
            unicode_display = unicode_highlight;
          else
            fatal (_("invalid argument to -U/--unicode: %s"), optarg);
          break;

        case 'H':
          usage (stdout, 0);
          /* No need to set seenflag or to break - usage() does not return.  */
        default:
          usage (stderr, 1);
        }
    }

  if (show_version)
    print_version ("objdump");

  if (!seenflag)
    usage (stderr, 2);

  dump_any_debugging = (dump_debugging
                        || dump_dwarf_section_info
                        || process_links);

  if (formats_info)
    exit_status = display_info ();
  else
    {
      if (optind == argc)
        display_file ("a.out", target, true);
      else
        for (; optind < argc;)
          {
            display_file (argv[optind], target, optind == argc - 1);
            optind++;
          }
    }

  free_only_list ();
  free (dump_ctf_section_name);
  free (dump_ctf_parent_name);
  free ((void *) source_comment);

  END_PROGRESS (program_name);

  return exit_status;
}