diff --git a/binutils.spec b/binutils.spec
index 3872d94..329738f 100644
--- a/binutils.spec
+++ b/binutils.spec
@@ -39,7 +39,7 @@
 Summary: A GNU collection of binary utilities
 Name: binutils%{?name_cross}%{?_with_debug:-debug}
 Version: 2.37
-Release: 11%{?dist}
+Release: 12%{?dist}
 License: GPLv3+
 URL: https://sourceware.org/binutils
 
@@ -291,6 +291,10 @@ Patch20: binutils-bfd-close-fds.patch
 # Lifetime: Fixed in 2.38.
 Patch21: binutils-gas-Use-the-directory-name-in-.file-0.patch
 
+# Purpose:  Add ability to show unicode characters to display tools
+# Lifetime: Fixed in 2.38.
+Patch22: binutils.unicode.patch
+
 #----------------------------------------------------------------------------
 
 Provides: bundled(libiberty)
@@ -908,6 +912,9 @@ exit 0
 
 #----------------------------------------------------------------------------
 %changelog
+* Tue Nov 09 2021 Nick Clifton <nickc@redhat.com> - 2.37-12
+- Add ability to show unicode characters to display tools.
+
 * Mon Nov 08 2021 Nick Clifton  <nickc@redhat.com> - 2.37-11
 - Add upstream patch to use the directory name in .file 0, fixes ccache FTBFS (#1996936)
 
diff --git a/binutils.unicode.patch b/binutils.unicode.patch
new file mode 100644
index 0000000..903ae95
--- /dev/null
+++ b/binutils.unicode.patch
@@ -0,0 +1,32545 @@
+diff -rupN binutils.orig/binutils/NEWS binutils-2.37/binutils/NEWS
+--- binutils.orig/binutils/NEWS	2021-11-09 12:34:21.664802928 +0000
++++ binutils-2.37/binutils/NEWS	2021-11-09 12:38:05.757327773 +0000
+@@ -1,5 +1,14 @@
+ -*- text -*-
+ 
++* Tools which display symbols or strings (readelf, strings, nm, objdump)
++  have a new command line option which controls how unicode characters are
++  handled.  By default they are treated as normal for the tool.  Using
++  --unicode=locale will display them according to the current locale.
++  Using --unicode=hex will display them as hex byte values, whilst
++  --unicode=escape will display them as escape sequences.  In addition
++  using --unicode=highlight will display them as unicode escape sequences
++  highlighted in red (if supported by the output device).
++
+ Changes in 2.37:
+ 
+ * The readelf tool has a new command line option which can be used to specify
+diff -rupN binutils.orig/binutils/NEWS.orig binutils-2.37/binutils/NEWS.orig
+--- binutils.orig/binutils/NEWS.orig	1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.37/binutils/NEWS.orig	2021-11-09 12:34:46.290643870 +0000
+@@ -0,0 +1,823 @@
++-*- text -*-
++
++Changes in 2.37:
++
++* The readelf tool has a new command line option which can be used to specify
++  how the numeric values of symbols are reported.  --sym-base=0|8|10|16 tells
++  readelf to display the values in base 8, base 10 or base 16.  A sym base of 0
++  represents the default action of displaying values under 10000 in base 10 and
++  values above that in base 16.
++
++* Binutils now requires a C99 compiler and library to build.
++
++* A new format has been added to the nm program.  Specifying
++  --format=just-symbols (or just using -j) will tell the program to only
++  display symbol names and nothing else.
++
++* A new command line --keep-section-symbols has been added to objcopy and
++  strip.  This stops the removal of unused section symbols when the file is
++  copied.  Removing these symbols saves space, but sometimes they are needed by
++  other tools.
++
++* objcopy --weaken, --weaken-symbol and --weaken-symbols now make undefined
++  symbols weak on targets that support weak symbols.
++
++* Readelf and objdump can now display and use the contents of .debug_sup
++  sections.
++
++* Readelf and objdump will now follow links to separate debug info files by
++  default.  This behaviour can be stopped via the use of the new -wN or
++  --debug-dump=no-follow-links options for readelf and the -WN or
++  --dwarf=no-follow-links options for objdump.  Also the old behaviour can be
++  restored by the use of the --enable-follow-debug-links=no configure time
++  option.
++
++  The semantics of the =follow-links option have also been slightly changed.
++  When enabled, the option allows for the loading of symbol tables and string
++  tables from the separate files which can be used to enhance the information
++  displayed when dumping other sections, but it does not automatically imply
++  that information from the separate files should be displayed.
++
++  If other debug section display options are also enabled (eg
++  --debug-dump=info) then the contents of matching sections in both the main
++  file and the separate debuginfo file *will* be displayed.  This is because in
++  most cases the debug section will only be present in one of the files.
++
++  If however non-debug section display options are enabled (eg --sections) then
++  the contents of matching parts of the separate debuginfo file will *not* be
++  displayed.  This is because in most cases the user probably only wanted to
++  load the symbol information from the separate debuginfo file.  In order to
++  change this behaviour a new command line option --process-links can be used.
++  This will allow di0pslay options to applied to both the main file and any
++  separate debuginfo files.
++
++* Nm has a new command line option: --quiet.  This suppresses "no symbols"
++  diagnostic.
++
++Changes in 2.36:
++
++* Update elfedit and readelf with LAM_U48 and LAM_U57 support.
++
++* Nm has a new command line option: --ifunc-chars=CHARS.  This specifies a
++  string of one or two characters.  The first character is used as the type
++  character when displaying global ifunc symbols.  The second character, if
++  present is used when displaying local ifunc symbols.
++
++  In addition a new configure time option --enable-f-for-ifunc-symbols has been
++  created, which if used will change nm's default characters for ifunc symbols
++  from i (both local and global) to F (global) and f (local).
++
++* The ar tool's previously unused l modifier is now used for specifying
++  dependencies of a static library. The arguments of this option
++  (or --record-libdeps long form option) will be stored verbatim in the
++  __.LIBDEP member of the archive, which the linker may read at link time.
++
++* Readelf can now display the contents of LTO symbol table sections when asked
++  to do so via the --lto-syms command line option.
++
++* Readelf now accepts the -C command line option to enable the demangling of
++  symbol names.  In addition the --demangle=<style>, --no-demangle,
++  --recurse-limit and --no-recurse-limit options are also now availale.
++
++* Add support for the SHF_GNU_RETAIN ELF section flag.
++  This flag specifies that the section should not be garbage collected by the
++  linker.
++
++Changes in 2.35:
++
++* Changed readelf's display of symbol names when wide mode is not enabled.
++  If the name is too long it will be truncated and the last five characters
++  replaced with "[...]".  The old behaviour of displaying 5 more characters but
++  not indicating that truncation has happened can be restored by the use of the
++  -T or --silent-truncation options.
++
++* X86 NaCl target support is removed.
++
++* The readelf tool now has a -L or --lint or --enable-checks option which turns
++  on warning messages about possible problems with the file(s) being examined.
++  These checks include things like zero-sized sections, which are allowed by
++  the ELF standard but which nevertheless might be of concern if the user
++  was expecting them to actually contain something.
++
++Changes in 2.34:
++
++* Binutils now supports debuginfod, an HTTP server for distributing
++  ELF/DWARF debugging information as well as source code. When built with
++  debuginfod, readelf and objdump can automatically query debuginfod
++  servers for separate debug files when they otherwise cannot be found.
++  To build binutils with debuginfod, pass --with-debuginfod to configure.
++  This requires libdebuginfod, the debuginfod client library. debuginfod
++  is distributed with elfutils, starting with version 0.178. For more
++  information see https://sourceware.org/elfutils.
++
++* Add --output option to the "ar" program.  This option can be used to specify
++  the output directory when extracting members from an archive.
++
++* Add --keep-section option to objcopy and strip.  This option keeps the
++  specified section from being removed.
++
++ * Add visualization of jumps inside a function by drawing an ascii character
++   graph between the address and the disassembler column.  Enabled via the
++   --visualize-jumps command line option for objdump.  Currently supported by
++   the x86, x86_64, and ARM targets.  The output looks something like this:
++
++  c6:	|  |     \----------> be 00 00 00 00       	mov    $0x0,%esi
++  cb:	|  |           /----> 48 8b 3d 00 00 00 00 	mov    0x0(%rip),%rdi        # d2 <main+0xd2>
++  d2:	|  |           |      31 c0                	xor    %eax,%eax
++  d4:	|  |           |  /-- e8 00 00 00 00       	callq  d9 <main+0xd9>
++  d9:	|  |           |  \-> bf 02 00 00 00       	mov    $0x2,%edi
++  de:	|  +-----------|----- e8 00 00 00 00       	callq  e3 <main+0xe3>
++  e3:	|  \-----------|----> 48 89 da             	mov    %rbx,%rdx
++  e6:	|              |      be 00 00 00 00       	mov    $0x0,%esi
++  eb:	|              \----- eb de                	jmp    cb <main+0xcb>
++  ed:	\-------------------> 48 8b 16             	mov    (%rsi),%rdx
++
++  Additional arguments to the --visualize-jumps option add colors to the
++  output.
++
++Changes in 2.33:
++
++* Add --source-comment[=<txt>] option to objdump which if present,
++  provides a prefix to source code lines displayed in a disassembly.
++
++* Add --set-section-alignment <section-name>=<align> option to objcopy to allow
++  the changing of section alignments.
++
++* Add --verilog-data-width option to objcopy for verilog targets to control
++  width of data elements in verilog hex format.
++
++* Add support for the Armv8.1-M Mainline and M-profile Vector Extension (MVE)
++  instructions.
++
++* The separate debug info file options of readelf (--debug-dump=links
++  and --debug-dump=follow) and objdump (--dwarf=links and
++  --dwarf=follow-links) will now display and/or follow multiple links if
++  more than one are present in a file.  (This usually happens when gcc's
++  -gsplit-dwarf option is used).
++
++  In addition objdump's --dwarf=follow-links now also affects its other
++  display options, so that for example, when combined with --syms it will
++  cause the symbol tables in any linked debug info files to also be
++  displayed.  In addition when combined with --disassemble the --dwarf=
++  follow-links option will ensure that any symbol tables in the linked
++  files are read and used when disassembling code in the main file.
++
++ * Add support for dumping types encoded in the Compact Type Format
++   to objdump and readelf.
++
++Changes in 2.32:
++
++* The addr2line, c++filt, nm and objdump tools now have a limit on the
++  maximum amount of recursion that is allowed whilst demangling strings.
++  The value for this limit is defined by the DEMANGLE_RECRUSE_LIMIT
++  constant declared in the include/demangle.h header file.  At the time
++  of writing this constant has the value of 2048.
++
++  The --no-recurse-limit option can be used to remove the limit, restoring
++  the behaviour of earlier versions of these tools.  This may be needed in
++  order to dmangle truly complicated names, but it also leaves the tools
++  vulnerable to stack exhaustion from maliciously constructed mangled names.
++
++* Objdump's --disassemble option can now take a parameter, specifying the
++  starting symbol for disassembly.  Disassembly will continue from this
++  symbol up to the next symbol or the end of the function.
++
++* The MIPS port now supports the Loongson 2K1000 processor which implements
++  the MIPS64r2 ISA, the Loongson-mmi ASE, Loongson-cam ASE, Loongson-ext ASE,
++  Loongson-ext2 ASE and MSA ASE instructions. Add -march=gs264e option for
++  Loongson 2K1000 processor.
++
++* The MIPS port now supports the Loongson 3A2000/3A3000 processor which
++  implements the MIPS64r2 ISA, the Loongson-mmi ASE, Loongson-cam ASE,
++  Loongson-ext ASE and Loongson-ext2 ASE instructions. Add -march=gs464e
++  option for Loongson 3A2000/3A3000 processor.
++
++* The MIPS port now supports the Loongson 3A1000 processor, aka Loongson3a,
++  which implements the MIPS64r2 ISA, the Loongson-mmi ASE, Loongson-cam ASE
++  and Loongson-ext ASE instructions. Add -march=gs464 option for Loongson
++  3A1000 processor, The -march=loongson3a is an alias of -march=gs464 for
++  compatibility.
++
++* The size tool now has a new output format '--format=GNU' or '-G'.  The
++  results are displayed in a similar manor to the default berkeley layout,
++  except read-only data is counted in the data column, not the text column.
++  Additionally the total is only included once.
++
++Changes in 2.31:
++
++* Add support for disassembling netronome Flow Processor (NFP) firmware files.
++
++* The AArch64 port now supports showing disassembly notes which are emitted
++  when inconsistencies are found with the instruction that may result in the
++  instruction being invalid.  These can be turned on with the option -M notes
++  to objdump.
++
++* The AArch64 port now emits warnings when a combination of an instruction and
++  a named register could be invalid.
++
++* Added O modifier to ar to display member offsets inside an archive
++
++Changes in 2.30:
++
++* Add --debug-dump=links option to readelf and --dwarf=links option to objdump
++  which displays the contents of any .gnu_debuglink or .gnu_debugaltlink
++  sections.
++
++  Add a --debug-dump=follow-links option to readelf and a --dwarf=follow-links
++  option to objdump which causes indirect links into separate debug info files
++  to be followed when dumping other DWARF sections.
++
++Changes in 2.29:
++
++* The MIPS port now supports microMIPS eXtended Physical Addressing (XPA)
++  instructions for assembly and disassembly.
++
++* The MIPS port now supports the microMIPS Release 5 ISA for assembly and
++  disassembly.
++
++* The MIPS port now supports the Imagination interAptiv MR2 processor,
++  which implements the MIPS32r3 ISA, the MIPS16e2 ASE as well as a couple
++  of implementation-specific regular MIPS and MIPS16e2 ASE instructions.
++
++* The SPARC port now supports the SPARC M8 processor, which implements the
++  Oracle SPARC Architecture 2017.
++
++* The MIPS port now supports the MIPS16e2 ASE for assembly and disassembly.
++
++* Add support for ELF SHF_GNU_MBIND and PT_GNU_MBIND_XXX.
++
++* Add support for the wasm32 ELF conversion of the WebAssembly file format.
++
++* Add --inlines option to objdump, which extends the --line-numbers option
++  so that inlined functions will display their nesting information.
++
++* Add --merge-notes options to objcopy to reduce the size of notes in
++  a binary file by merging and deleting redundant notes.
++
++* Add support for locating separate debug info files using the build-id
++  method, where the separate file has a name based upon the build-id of
++  the original file.
++
++Changes in 2.28:
++
++* This version of binutils fixes a problem with PowerPC VLE 16A and 16D
++  relocations which were functionally swapped, for example,
++  R_PPC_VLE_HA16A performed like R_PPC_VLE_HA16D while R_PPC_VLE_HA16D
++  performed like R_PPC_VLE_HA16A.  This could have been fixed by
++  renumbering relocations, which would keep object files created by an
++  older version of gas compatible with a newer ld.  However, that would
++  require an ABI update, affecting other assemblers and linkers that
++  create and process the relocations correctly.  It is recommended that
++  all VLE object files be recompiled, but ld can modify the relocations
++  if --vle-reloc-fixup is passed to ld.  If the new ld command-line
++  option is not used, ld will ld warn on finding relocations inconsistent
++  with the instructions being relocated.
++
++* The nm program has a new command-line option (--with-version-strings)
++  which will display a symbol's version information, if any, after the
++  symbol's name.
++
++* The ARC port of objdump now accepts a -M option to specify the extra
++  instruction class(es) that should be disassembled.
++
++* The --remove-section option for objcopy and strip now accepts section
++  patterns starting with an exclamation point to indicate a non-matching
++  section.  A non-matching section is removed from the set of sections
++  matched by an earlier --remove-section pattern.
++
++* The --only-section option for objcopy now accepts section patterns
++  starting with an exclamation point to indicate a non-matching section.
++  A non-matching section is removed from the set of sections matched by
++  an earlier --only-section pattern.
++
++* New --remove-relocations=SECTIONPATTERN option for objcopy and strip.
++  This option can be used to remove sections containing relocations.
++  The SECTIONPATTERN is the section to which the relocations apply, not
++  the relocation section itself.
++
++Changes in 2.27:
++
++* Add a configure option, --enable-64-bit-archive, to force use of a
++  64-bit format when creating an archive symbol index.
++
++* Add --elf-stt-common= option to objcopy for ELF targets to control
++  whether to convert common symbols to the STT_COMMON type.
++
++Changes in 2.26:
++
++* Add option to objcopy to insert new symbols into a file:
++  --add-symbol <name>=[<section>:]<value>[,<flags>]
++
++* Add support for the ARC EM/HS, and ARC600/700 architectures.
++
++* Extend objcopy --compress-debug-sections option to support
++  --compress-debug-sections=[none|zlib|zlib-gnu|zlib-gabi] for ELF
++  targets.
++
++* Add --update-section option to objcopy.
++
++* Add --output-separator option to strings.
++
++Changes in 2.25:
++
++* Add --data option to strings to only print strings in loadable, initialized
++  data sections.  Change the default behaviour to be --all, but add a new
++  configure time option of --disable-default-strings-all to restore the old
++  default behaviour.
++
++* Add --include-all-whitespace to strings.
++
++* Add --dump-section option to objcopy.
++
++* Add support for the Andes NDS32.
++
++Changes in 2.24:
++
++* Objcopy now supports wildcard characters in command-line options that take
++  section names.
++
++* Add support for Altera Nios II.
++
++Changes in 2.23:
++
++* Add support for the VLE extension to the PowerPC architecture.
++
++* Add support for x64 Windows target of the delayed-load-library.
++
++* Add support for the Renesas RL78 architecture.
++
++Changes in 2.22:
++
++* Add support for displaying the contents of .debug.macro sections.
++
++* Add --preprocessor-arg option to windres to specify additional options
++  passed to preprocessor.
++
++* Add --dwarf-start and --dwarf-end to readelf and objdump.  These are used by
++  the new Emacs mode, see dwarf-mode.el.
++
++* Add support for the Tilera TILEPro and TILE-Gx architectures.
++
++changes in 2.21:
++
++* Add --interleave-width option to objcopy to allowing copying a range of
++  bytes from the input to the output with the --interleave option.
++
++* Add support for the TMS320C6000 (TI C6X) processor family.
++
++* Readelf can now display ARM unwind tables (.ARM.exidx / .ARM.extab) using
++  the -u / --unwind option.
++
++* Add --dyn-syms to readelf to dump dynamic symbol table.
++
++* A new tool - elfedit - has been added to directly manipulate ELF format
++  binaries.
++
++* Add to dlltool .def file feature of aliasing PE internal symbol name by
++  '== <ID>' option.
++
++* Add a new command-line option -a / --addresses to addr2line to display the
++  address before function name or source filename.
++
++* Add a new command-line option -p / --pretty-print to addr2line to have
++  a more human readable output.
++
++* The hppa/som targets can now be compiled on any host.
++
++Changes in 2.20:
++
++* Add support for delay importing to dlltool.  Use the --output-delaylib <file>
++  switch to create a delay-import library.  The resulting app will load the dll
++  as soon as the first function is called.  It will link to __delayLoadHelper2()
++  from the static delayimp library, which will import LoadLibraryA and
++  GetProcAddress from kernel32.
++
++* Add a new command-line option, --insn-width=WIDTH, to objdump to specify
++  number of bytes to be displayed on a single line when disassembling
++  instructions.
++
++* Readelf can now display the relocated contents of a section as a sequence
++  of bytes via the --relocated-dump=<name|number> command-line option.
++
++* The gprof program has been given a new command-line option:
++  --external-symbols-table=<filename> which reads in symbols from a specified
++  file.
++
++* The plugin target has been added to bfd. It can load the same shared objects
++  used by gold and uses them to provide basic support for new file formats.
++
++* The verilog memory hex dump file format is now supported as an output format
++  for objcopy.
++
++* Add --file-alignment, --heap, --image-base, --section-alignment,
++  --stack and --subsystem command-line options to objcopy, which will
++  set PE optional header.
++
++* Option --dwarf/-W of objdump is now as flexible as readelf --debug-dump/-w.
++
++* --as-needed now links in a dynamic library if it satisfies undefined
++  symbols in regular objects, or in other dynamic libraries.  In the
++  latter case the library is not linked if it is found in a DT_NEEDED
++  entry of one of the libraries already linked.
++
++* Added --prefix=PREFIX and --prefix-strip=LEVEL switches to objdump to
++  add absolute paths for -S.
++
++* Add new option --use-nul-prefixed-import-tables to dlltool to allow fall-
++  back to old import table generation with null element prefix.
++
++* Added --identify-strict switch to cause --identify <implib> to
++  report an error when the import library is associated with
++  multiple DLLs.
++
++* Added --identify <implib> option to dlltool, which determines the
++  name of the DLL associated with the specified <implib>.
++
++* Support for PowerPC booke64 instructions has been removed.  The assembler no
++  longer accepts -mbooke32 or -mbooke64 and the disassembler no longer accepts
++  -Mbooke32 or -Mbooke64.  Instead, -mbooke and -Mbooke should be used.
++
++Changes in 2.19:
++
++* Added -wL switch to dump decoded contents of .debug_line.
++
++* Added support for "thin" archives which contain pathnames pointing to
++  object files rather than the files themselves and which contain a
++  flattened symbol index for all objects, and archives, which have been
++  added to the archive.
++
++* Added -F switch to objdump to include file offsets in the disassembly.
++
++* Added -c switch to readelf to allow string dumps of archive symbol index.
++
++* Support for SSE5 has been added to the i386 port.
++
++* Added -p switch to readelf to allow string dumps of sections.
++
++Changes in 2.18:
++
++* Resolved 37 coding problems in bfd including static array overruns, null
++  pointer dereferences and use of a malloc buffer after it has been freed, as
++  revealed by static analysis donated by Coverity, Inc. (http://scan.coverity.com).
++
++* The binutils sources are now released under version 3 of the GNU General
++  Public License.
++
++* A new tool "windmc" has been added for some targets.  This is a message
++  compiler which attempts to be compatible with the MS version.
++
++* Add codepage support to the windres tool.  It now supports many new
++  resource types (e.g. MANIFEST, TOOLBAR, etc).  The output generation
++  for binary files is done now via bfd itself.  The endianess problems
++  for different hosts are solved.  Dumps of .res files can now be
++  re-compiled by windres without lossing resources or compilation errors.
++  Some problems on dialog resource translations are corrected.
++
++* Add --extract-symbol command-line option to objcopy, which will
++  strip everything out of an ordinary object file or executable except
++  for its symbol table.  Files containing just symbols can be useful
++  to some OSes.
++
++Changes in 2.17:
++
++* Add "-x NAME" to readelf in addition to "-x NUMBER".
++
++* Add -i and -t switches to cxxfilt.  -i disables the display of implementation
++  specific extra demangling information (if any) and -t disables the demangling
++  of types.
++
++* Add support for the "@<file>" syntax to the command lines of all tools, so
++  that extra switches can be read from <file>.
++
++* Add "-W/--dwarf" to objdump to display the contents of the DWARF
++  debug sections.
++
++* Add "-t/--section-details" to readelf to display section details.
++  "-N/--full-section-name" is deprecated.
++
++* powerpc-linux ld now supports a variant form of PLT and GOT for the security
++  conscious.  This form will automatically be chosen when ld detects that all
++  code in regular object files was generated by gcc -msecure-plt.  The old PLT
++  and GOT may be forced by a new ld option, --bss-plt.
++
++* Add "-i/--inlines" to addr2line to print enclosing scope information
++  for inlined function chains, back to first non-inlined function.
++
++* Add "-N/--full-section-name" to readelf to display full section name.
++
++* Add "-M entry:<addr>" switch to objdump to specify a function entry address
++  when disassembling VAX binaries.
++
++* Add "--globalize-symbol <name>" and "--globalize-symbols <filename>" switches
++  to objcopy to convert local symbols into global symbols.
++
++* gprof now allows input files to have histogram records for
++  several memory ranges, provided those ranges are disjoint.
++
++Changes in 2.16:
++
++* Add "-g/--section-groups" to readelf to display section groups.
++
++* objcopy recognizes two new options --strip-unneeded-symbol and
++  --strip-unneeded-symbols, namely for use together with the wildcard
++  matching the original --strip-symbol/--strip-symbols provided, but
++  retaining any symbols matching but needed by relocations.
++
++* readelf can now display address ranges from .debug_range sections.  This
++  happens automatically when a DW_AT_range attribute is encountered.  The
++  command-line switch --debug-dump=Ranges (or -wR) can also be used to display
++  the contents of the .debug_range section.
++
++* nm and objdump now have a switch "--special-syms" to enable the displaying of
++  symbols which the target considers to be special.  By default these symbols
++  are no longer displayed.  Currently the only special symbols are the Mapping
++  symbols used by the ARM port to mark transitions between text and data and
++  between ARM and THUMB code.
++
++* dlltool has a switch "--ext-prefix-alias <prefix>" to generate additional
++  import and export symbols with <preifx> prepended to them.
++
++Changes in 2.15:
++
++* objcopy for MIPS targets now accepts "-M no-aliases" as an option to the
++  disassembler to print the "raw" mips instruction mnemonic instead of some
++  pseudo instruction name.  I.E. print "daddu" or "or" instead of "move",
++  "sll" instead of "nop", etc.
++
++* objcopy and strip can now take wildcard patterns in symbol names specified on
++  the command line provided that the --wildcard switch is used to enable them.
++
++* readelf can now parse archives.
++
++* objdump now accepts --debugging-tags to print the debug information in a
++  format compatible with ctags tool.
++
++* objcopy and strip now accept --only-keep-debug to create a file containing
++  those sections that would be stripped out by --strip-debug.  The idea is that
++  this can be used in conjunction with the --add-gnu-debuglink switch to create
++  a two part program distribution - one a stripped executable and the other the
++  debugging info.
++
++* objcopy now accepts --add-gnu-debuglink=<file> to insert a .gnu_debuglink
++  section into a (presumably stripped) executable.  This allows the debug
++  information for the file to be held in a separate file.
++
++* BFD marks the sections .comment and .note as 'n' in the BSD/POSIX
++  single-character representation.  This can be checked by running nm
++  with the -a switch.
++
++Changes in 2.14:
++
++* Added --info switch to objcopy and strip.
++
++* Support for Vitesse IQ2000 added by Red Hat.
++
++* Added 'S' encoding to strings to allow the display of 8-bit characters.
++
++* Added --prefix-symbols=<text>, --prefix-sections=<text> and
++  --prefix-alloc-sections=<text> to objcopy.
++
++* readelf can handle the extensions to the DWARF2 spec used by the Unified
++  Parallel C compiler.
++
++* BFD no longer declares a "boolean" type, to avoid clashes with other
++  headers that declare the same.  Users of BFD should replace boolean,
++  false and true, with int, 0 and 1, or define their own boolean type.
++
++* Support for IP2K added by Denis Chertykov.
++
++Changes in 2.13:
++
++* Support for the Fujitsu FRV architecture added by Red Hat. Models for FR400
++  and FR500 included.
++
++Changes in version 2.12:
++
++* Support for Don Knuth's MMIX, by Hans-Peter Nilsson.
++
++* size: Add --totals to display summary of sizes (Berkeley format only).
++
++* readelf: Add --wide option to not break section header or segment listing
++  lines to fit into 80 columns.
++
++* strings: Add --encoding to display wide character strings.  By Markus Kuhn.
++
++* objcopy: Add --rename-section to change section names.
++
++* readelf: Support added for DWARF 2.1 extensions.  Support added for
++  displaying the contents of .debug.macinfo sections.
++
++* New command-line switches added to objcopy to allow symbols to be kept as
++  global symbols, and also to specify files containing lists of such symbols.
++  by Honda Hiroki.
++
++* Support for OpenRISC by Johan Rydberg.
++
++* New command-line switch to objcopy --alt-machine-code which creates a binary
++  with an alternate machine code if one is defined in the architecture
++  description.  Only supported for ELF targets.  By Alexandre Oliva.
++
++* New command-line switch to objcopy -B (or --binary-architecture) which sets
++  the architecture of the output file to the given argument.  This option only
++  makes sense, if the input target is binary.  Otherwise it is ignored.
++  By Stefan Geuken.
++
++* Support for PDP-11 by Lars Brinkhoff.
++
++Changes in binutils 2.11:
++
++* Add support for ARM v5t and v5te architectures and Intel's XScale ARM
++  extenstions.
++
++* Add --srec-len and --srec-forceS3 command-line switch to objcopy.
++  By Luciano Gemme.
++
++* Support for the MIPS32, by Anders Norlander.
++
++* Support for the i860, by Jason Eckhardt.
++
++* Support for CRIS (Axis Communications ETRAX series).
++
++Changes in binutils 2.10:
++
++* Support for 64-bit ELF on HPPA.
++
++* New command-line switch to objdump --file-start-context which shows the
++  entire file contents up to the source line first encountered for a given
++  file.
++
++* New command-line switch to objdump -M (or --disassembler-options) which takes
++  a parameter which can then be interpreted on a per-target basis by the
++  disassembler.  Used by ARM targets to select register name sets, ISA, APCS or
++  raw verions.
++
++* objdump support for -mi386:intel which causes disassembly to be displayed
++  with intel syntax.
++
++* New program: readelf.  This displays the contents of ELF format files,
++  regardless of target machine.
++
++* objcopy now takes --change-section-lma, --change-section-vma, and
++  --change-section-address options.  The old --adjust-section-vma option is
++  equivalent to --change-section-address.  The other --adjust-* options are now
++  renamed to --change-*, although --adjust-* continues to work.
++
++* objcopy has a --redefine-sym option that lets you rename symbols.
++
++* objcopy now takes a -j/--only-section option to copy only the specified
++  sections.
++
++* dlltool now supports the IMPORTS command.
++
++* dlltool now takes --export-all-symbols, --no-export-all-symbols,
++  --exclude-symbols, and --no-default-excludes options.
++
++Changes in binutils 2.9:
++
++* Added windres program, which can be used to manipulate resources in WIN32
++  files as used on Windows 95 and Windows NT.
++
++* The objcopy --gap-fill and --pad-to options operate on the LMA rather than
++  the VMA of the sections.
++
++* Added S modifier to ar to not build a symbol table.
++
++Changes in binutils 2.8:
++
++* The objdump disassembly format has been changed, and hopefully improved.  Use
++  the new --prefix-addresses option to get the old format.  There are also new
++  --disassemble-zeroes and --no-show-raw-insn options which affect disassembler
++  output.
++
++* Formats may now be specified as configuration triplets.  For example,
++  objdump -b i386-pc-linux.  The triplets are not passed through config.sub,
++  so they must be in canonical form.
++
++* Added new addr2line program.  This uses the debugging information to convert
++  an address into a file name and line number within a program.
++
++* Added --change-leading-char argument to objcopy.
++
++* Added --weaken argument to objcopy.
++
++* objdump --dynamic-reloc now works on ELF executables and shared libraries.
++
++* Added --adjust-vma option to objdump.
++
++* Added -C/--demangle option to objdump.
++
++* Added -p/--preserve-dates option to strip and objcopy.
++
++Changes in binutils 2.7:
++
++* Added --enable-shared and --enable-commonbfdlib options to configure.
++
++* Added --debugging argument to objdump and objcopy.
++
++* Added --defined-only argument to nm.
++
++* Added --remove-leading-char argument to objcopy.
++
++* The objdump --line-numbers option is now meaningful with --reloc.
++
++* Added --line-numbers option to nm.
++
++* Added --endian/-EB/-EL option to objdump.
++
++* Added support for Alpha OpenVMS/AXP.
++
++Changes in binutils 2.6:
++
++* Added -N/--strip-symbol and -K/--keep-symbol arguments to strip and objcopy.
++
++* Added several arguments to objcopy to provide some control over how the new
++  file is laid out in memory.  Also added binary output format to BFD to permit
++  generating plain binary files.
++
++* Added --start-address and --stop-address options to objdump.
++
++* ar and ranlib now work on AIX.  The tools are now built by default on AIX.
++
++Changes in binutils 2.5:
++
++* Changed objdump -dr to dump the relocs interspersed with the assembly
++  listing, for a more useful listing of relocatable files.
++
++* Changed objdump -d/--disassemble to only disassemble SEC_CODE sections.
++  Added -D/--disassemble-all option to disassemble all sections.
++
++* Added --size-sort option to nm.
++
++* strip and objcopy should now be able to handle dynamically linked ELF
++  executables.
++
++Changes in binutils 2.4:
++
++* Support for HP-PA (by Jeff Law), i386 Mach (by David Mackenzie), RS/6000 and
++  PowerPC (except ar and ranlib; by Ian Taylor).
++
++* Support for Irix 5.
++
++* Programs `strip' and `objcopy' will not attempt to write dynamically linked
++  ELF output files, since BFD currently can't create them properly.
++
++Changes in binutils 2.3:
++
++* A new --stabs argument has been added to objdump to dump stabs sections in
++  ELF and COFF files.
++
++* A new program, nlmconv, has been added.  It can convert object files into
++  Novell NetWare Loadable Modules.
++
++* The strings program has been added.
++
++Changes in binutils 2.2:
++
++* The 'copy' program has been renamed to 'objcopy', for consistency with
++  'objdump', and because 'copy' might more plausibly be used as a synonym for
++  'cp'.
++
++* The new stand-alone program c++filt is a filter that converts encoded
++  (mangled) C++ assembly-level identifiers to user-level names.  (Note: This
++  may get moved to the gcc distribution.)
++
++* nm -o on an archive now prefixes each line with the archive name, matching
++  the output from BSD nm.
++
++* ar (and ld) can now read (but not write) BSD4.4-style archives.
++
++* New support for H8500, Z8000, and the Hitach SH.
++
++* Dis-assembler interface changed to allow sharing with gdb.
++
++* There is new Elf code, but it is not yet ready for general use.
++
++* There is the beginnings of a test suite.
++
++Changes in binutils 2.1:
++
++* There is now support for writing ECOFF files, so ld and the other utilities
++  should work on Risc/Ultrix and Irix.  Please let us know how well this works.
++
++* ar now automatically creates a symbol table (a __.SYMDEF member, in the BSD
++  version), if there are any object files in the archive.  So running ranlib is
++  now redundant (unless the non-standard q command is used).  This is required
++  for Posix.2 conformance.
++
++* The archive-reading code now reads both BSD-style and SYSV-style archives
++  independently of the selected target format.  This is to encourage people to
++  switch to SYSV-format, which has a number of advantages.
++
++* The strip and copy programs now have options to remove debug-symbols only
++  and/or local symbols only.  They now also support long options.
++
++
++Copyright (C) 2012-2021 Free Software Foundation, Inc.
++
++Copying and distribution of this file, with or without modification,
++are permitted in any medium without royalty provided the copyright
++notice and this notice are preserved.
++
++Local variables:
++fill-column: 79
++End:
+diff -rupN binutils.orig/binutils/NEWS.rej binutils-2.37/binutils/NEWS.rej
+--- binutils.orig/binutils/NEWS.rej	1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.37/binutils/NEWS.rej	2021-11-09 12:34:46.290643870 +0000
+@@ -0,0 +1,18 @@
++--- binutils/NEWS
+++++ binutils/NEWS
++@@ -2,6 +2,15 @@
++ 
++ * Add support for the LoongArch instruction set.
++ 
+++* Tools which display symbols or strings (readelf, strings, nm, objdump)
+++  have a new command line option which controls how unicode characters are
+++  handled.  By default they are treated as normal for the tool.  Using
+++  --unicode=locale will display them according to the current locale.
+++  Using --unicode=hex will display them as hex byte values, whilst
+++  --unicode=escape will display them as escape sequences.  In addition
+++  using --unicode=highlight will display them as unicode escape sequences
+++  highlighted in red (if supported by the output device).
+++
++ Changes in 2.37:
++ 
++ * The readelf tool has a new command line option which can be used to specify
+diff -rupN binutils.orig/binutils/doc/binutils.texi binutils-2.37/binutils/doc/binutils.texi
+--- binutils.orig/binutils/doc/binutils.texi	2021-11-09 12:34:21.665802922 +0000
++++ binutils-2.37/binutils/doc/binutils.texi	2021-11-09 12:34:46.290643870 +0000
+@@ -812,6 +812,7 @@ nm [@option{-A}|@option{-o}|@option{--pr
+    [@option{-s}|@option{--print-armap}]
+    [@option{-t} @var{radix}|@option{--radix=}@var{radix}]
+    [@option{-u}|@option{--undefined-only}]
++   [@option{-U} @var{method}] [@option{--unicode=}@var{method}]
+    [@option{-V}|@option{--version}]
+    [@option{-X 32_64}]
+    [@option{--defined-only}]
+@@ -1132,6 +1133,21 @@ Use @var{radix} as the radix for printin
+ @cindex undefined symbols
+ Display only undefined symbols (those external to each object file).
+ 
++@item -U @var{[d|i|l|e|x|h]}
++@itemx --unicode=@var{[default|invalid|locale|escape|hex|highlight]}
++Controls the display of UTF-8 encoded mulibyte characters in strings.
++The default (@option{--unicode=default}) is to give them no special
++treatment.  The @option{--unicode=locale} option displays the sequence
++in the current locale, which may or may not support them.  The options
++@option{--unicode=hex} and @option{--unicode=invalid} display them as
++hex byte sequences enclosed by either angle brackets or curly braces.
++
++The @option{--unicode=escape} option displays them as escape sequences
++(@var{\uxxxx}) and the @option{--unicode=highlight} option displays
++them as escape sequences highlighted in red (if supported by the
++output device).  The colouring is intended to draw attention to the
++presence of unicode sequences where they might not be expected.
++
+ @item -V
+ @itemx --version
+ Show the version number of @command{nm} and exit.
+@@ -2247,6 +2263,7 @@ objdump [@option{-a}|@option{--archive-h
+         [@option{--prefix-strip=}@var{level}]
+         [@option{--insn-width=}@var{width}]
+         [@option{--visualize-jumps[=color|=extended-color|=off]}
++        [@option{-U} @var{method}] [@option{--unicode=}@var{method}]
+         [@option{-V}|@option{--version}]
+         [@option{-H}|@option{--help}]
+         @var{objfile}@dots{}
+@@ -2921,6 +2938,21 @@ When displaying symbols include those wh
+ special in some way and which would not normally be of interest to the
+ user.
+ 
++@item -U @var{[d|i|l|e|x|h]}
++@itemx --unicode=@var{[default|invalid|locale|escape|hex|highlight]}
++Controls the display of UTF-8 encoded mulibyte characters in strings.
++The default (@option{--unicode=default}) is to give them no special
++treatment.  The @option{--unicode=locale} option displays the sequence
++in the current locale, which may or may not support them.  The options
++@option{--unicode=hex} and @option{--unicode=invalid} display them as
++hex byte sequences enclosed by either angle brackets or curly braces.
++
++The @option{--unicode=escape} option displays them as escape sequences
++(@var{\uxxxx}) and the @option{--unicode=highlight} option displays
++them as escape sequences highlighted in red (if supported by the
++output device).  The colouring is intended to draw attention to the
++presence of unicode sequences where they might not be expected.
++
+ @item -V
+ @itemx --version
+ Print the version number of @command{objdump} and exit.
+@@ -3197,6 +3229,7 @@ strings [@option{-afovV}] [@option{-}@va
+         [@option{-n} @var{min-len}] [@option{--bytes=}@var{min-len}]
+         [@option{-t} @var{radix}] [@option{--radix=}@var{radix}]
+         [@option{-e} @var{encoding}] [@option{--encoding=}@var{encoding}]
++        [@option{-U} @var{method}] [@option{--unicode=}@var{method}]
+         [@option{-}] [@option{--all}] [@option{--print-file-name}]
+         [@option{-T} @var{bfdname}] [@option{--target=}@var{bfdname}]
+         [@option{-w}] [@option{--include-all-whitespace}]
+@@ -3288,6 +3321,28 @@ single-8-bit-byte characters, @samp{b} =
+ littleendian.  Useful for finding wide character strings. (@samp{l}
+ and @samp{b} apply to, for example, Unicode UTF-16/UCS-2 encodings).
+ 
++@item -U @var{[d|i|l|e|x|h]}
++@itemx --unicode=@var{[default|invalid|locale|escape|hex|highlight]}
++Controls the display of UTF-8 encoded mulibyte characters in strings.
++The default (@option{--unicode=default}) is to give them no special
++treatment, and instead rely upon the setting of the
++@option{--encoding} option.  The other values for this option
++automatically enable @option{--encoding=S}.
++
++The @option{--unicode=invalid} option treats them as non-graphic
++characters and hence not part of a valid string.  All the remaining
++options treat them as valid string characters.
++
++The @option{--unicode=locale} option displays them in the current
++locale, which may or may not support UTF-8 encoding.  The
++@option{--unicode=hex} option displays them as hex byte sequences
++enclosed between @var{<>} characters.  The @option{--unicode=escape}
++option displays them as escape sequences (@var{\uxxxx}) and the
++@option{--unicode=highlight} option displays them as escape sequences
++highlighted in red (if supported by the output device).  The colouring
++is intended to draw attention to the presence of unicode sequences
++where they might not be expected.
++
+ @item -T @var{bfdname}
+ @itemx --target=@var{bfdname}
+ @cindex object code format
+@@ -4796,6 +4851,7 @@ readelf [@option{-a}|@option{--all}]
+         [@option{--demangle@var{=style}}|@option{--no-demangle}]
+         [@option{--quiet}]
+         [@option{--recurse-limit}|@option{--no-recurse-limit}]
++        [@option{-U} @var{method}|@option{--unicode=}@var{method}]
+         [@option{-n}|@option{--notes}]
+         [@option{-r}|@option{--relocs}]
+         [@option{-u}|@option{--unwind}]
+@@ -4962,6 +5018,28 @@ necessary in order to demangle truly com
+ that if the recursion limit is disabled then stack exhaustion is
+ possible and any bug reports about such an event will be rejected.
+ 
++@item -U @var{[d|i|l|e|x|h]}
++@itemx --unicode=[default|invalid|locale|escape|hex|highlight]
++Controls the display of non-ASCII characters in identifier names.
++The default (@option{--unicode=locale} or @option{--unicode=default}) is
++to treat them as multibyte characters and display them in the current
++locale.  All other versions of this option treat the bytes as UTF-8
++encoded values and attempt to interpret them.  If they cannot be
++interpreted or if the @option{--unicode=invalid} option is used then
++they are displayed as a sequence of hex bytes, encloses in curly
++parethesis characters.
++
++Using the @option{--unicode=escape} option will display the characters
++as as unicode escape sequences (@var{\uxxxx}).  Using the
++@option{--unicode=hex} will display the characters as hex byte
++sequences enclosed between angle brackets.
++
++Using the @option{--unicode=highlight} will display the characters as 
++unicode escape sequences but it will also highlighted them in red,
++assuming that colouring is supported by the output device.  The
++colouring is intended to draw attention to the presence of unicode
++sequences when they might not be expected.
++
+ @item -e
+ @itemx --headers
+ Display all the headers in the file.  Equivalent to @option{-h -l -S}.
+diff -rupN binutils.orig/binutils/nm.c binutils-2.37/binutils/nm.c
+--- binutils.orig/binutils/nm.c	2021-11-09 12:34:21.661802947 +0000
++++ binutils-2.37/binutils/nm.c	2021-11-09 12:34:46.291643864 +0000
+@@ -38,6 +38,11 @@
+ #include "bucomm.h"
+ #include "plugin-api.h"
+ #include "plugin.h"
++#include "safe-ctype.h"
++
++#ifndef streq
++#define streq(a,b) (strcmp ((a),(b)) == 0)
++#endif
+ 
+ /* When sorting by size, we use this structure to hold the size and a
+    pointer to the minisymbol.  */
+@@ -216,6 +221,18 @@ static const char *plugin_target = NULL;
+ static bfd *lineno_cache_bfd;
+ static bfd *lineno_cache_rel_bfd;
+ 
++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;
++
+ enum long_option_values
+ {
+   OPTION_TARGET = 200,
+@@ -260,6 +277,7 @@ static struct option long_options[] =
+   {"target", required_argument, 0, OPTION_TARGET},
+   {"defined-only", no_argument, &defined_only, 1},
+   {"undefined-only", no_argument, &undefined_only, 1},
++  {"unicode", required_argument, NULL, 'U'},
+   {"version", no_argument, &show_version, 1},
+   {"with-symbol-versions", no_argument, &with_symbol_versions, 1},
+   {"without-symbol-versions", no_argument, &with_symbol_versions, 0},
+@@ -313,6 +331,8 @@ usage (FILE *stream, int status)
+   -t, --radix=RADIX      Use RADIX for printing symbol values\n\
+       --target=BFDNAME   Specify the target object format as BFDNAME\n\
+   -u, --undefined-only   Display only undefined symbols\n\
++  -U {d|s|i|x|e|h}       Specify how to treat UTF-8 encoded unicode characters\n\
++      --unicode={default|show|invalid|hex|escape|highlight}\n\
+       --with-symbol-versions  Display version strings after symbol names\n\
+   -X 32_64               (ignored)\n\
+   @FILE                  Read options from FILE\n\
+@@ -432,6 +452,187 @@ get_coff_symbol_type (const struct inter
+   return bufp;
+ }
+ 
++/* 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;
++}
++
++/* Convert any UTF-8 encoded characters in NAME into the form specified by
++   unicode_display.  Also converts control characters.  Returns a static
++   buffer if conversion was necessary.
++   Code stolen from objdump.c:sanitize_string().  */
++
++static const char *
++convert_utf8 (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;
++}
++
+ /* Print symbol name NAME, read from ABFD, with printf format FORM,
+    demangling it if requested.  */
+ 
+@@ -444,6 +645,7 @@ print_symname (const char *form, struct
+ 
+   if (name == NULL)
+     name = info->sinfo->name;
++
+   if (!with_symbol_versions
+       && bfd_get_flavour (abfd) == bfd_target_elf_flavour)
+     {
+@@ -451,6 +653,7 @@ print_symname (const char *form, struct
+       if (atver)
+ 	*atver = 0;
+     }
++
+   if (do_demangle && *name)
+     {
+       alloc = bfd_demangle (abfd, name, demangle_flags);
+@@ -458,6 +661,11 @@ print_symname (const char *form, struct
+ 	name = alloc;
+     }
+ 
++  if (unicode_display != unicode_default)
++    {
++      name = convert_utf8 (name);
++    }
++
+   if (info != NULL && info->elfinfo && with_symbol_versions)
+     {
+       const char *version_string;
+@@ -1807,7 +2015,7 @@ main (int argc, char **argv)
+     fatal (_("fatal error: libbfd ABI mismatch"));
+   set_default_bfd_target ();
+ 
+-  while ((c = getopt_long (argc, argv, "aABCDef:gHhjJlnopPrSst:uvVvX:",
++  while ((c = getopt_long (argc, argv, "aABCDef:gHhjJlnopPrSst:uU:vVvX:",
+ 			   long_options, (int *) 0)) != EOF)
+     {
+       switch (c)
+@@ -1900,6 +2108,24 @@ main (int argc, char **argv)
+ 	case 'u':
+ 	  undefined_only = 1;
+ 	  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 'V':
+ 	  show_version = 1;
+ 	  break;
+diff -rupN binutils.orig/binutils/nm.c.orig binutils-2.37/binutils/nm.c.orig
+--- binutils.orig/binutils/nm.c.orig	1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.37/binutils/nm.c.orig	2021-07-08 12:37:19.000000000 +0100
+@@ -0,0 +1,1973 @@
++/* nm.c -- Describe symbol table of a rel file.
++   Copyright (C) 1991-2021 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 of the License, 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, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
++   02110-1301, USA.  */
++
++#include "sysdep.h"
++#include "bfd.h"
++#include "progress.h"
++#include "getopt.h"
++#include "aout/stab_gnu.h"
++#include "aout/ranlib.h"
++#include "demangle.h"
++#include "libiberty.h"
++#include "elf-bfd.h"
++#include "elf/common.h"
++#define DO_NOT_DEFINE_AOUTHDR
++#define DO_NOT_DEFINE_FILHDR
++#define DO_NOT_DEFINE_LINENO
++#define DO_NOT_DEFINE_SCNHDR
++#include "coff/external.h"
++#include "coff/internal.h"
++#include "libcoff.h"
++#include "bucomm.h"
++#include "plugin-api.h"
++#include "plugin.h"
++
++/* When sorting by size, we use this structure to hold the size and a
++   pointer to the minisymbol.  */
++
++struct size_sym
++{
++  const void *minisym;
++  bfd_vma size;
++};
++
++/* When fetching relocs, we use this structure to pass information to
++   get_relocs.  */
++
++struct get_relocs_info
++{
++  asection **secs;
++  arelent ***relocs;
++  long *relcount;
++  asymbol **syms;
++};
++
++struct extended_symbol_info
++{
++  symbol_info *sinfo;
++  bfd_vma ssize;
++  elf_symbol_type *elfinfo;
++  coff_symbol_type *coffinfo;
++  /* FIXME: We should add more fields for Type, Line, Section.  */
++};
++#define SYM_VALUE(sym)       (sym->sinfo->value)
++#define SYM_TYPE(sym)        (sym->sinfo->type)
++#define SYM_STAB_NAME(sym)   (sym->sinfo->stab_name)
++#define SYM_STAB_DESC(sym)   (sym->sinfo->stab_desc)
++#define SYM_STAB_OTHER(sym)  (sym->sinfo->stab_other)
++#define SYM_SIZE(sym) \
++  (sym->elfinfo ? sym->elfinfo->internal_elf_sym.st_size: sym->ssize)
++
++/* The output formatting functions.  */
++static void print_object_filename_bsd (const char *);
++static void print_object_filename_sysv (const char *);
++static void print_object_filename_posix (const char *);
++static void do_not_print_object_filename (const char *);
++
++static void print_archive_filename_bsd (const char *);
++static void print_archive_filename_sysv (const char *);
++static void print_archive_filename_posix (const char *);
++static void do_not_print_archive_filename (const char *);
++
++static void print_archive_member_bsd (const char *, const char *);
++static void print_archive_member_sysv (const char *, const char *);
++static void print_archive_member_posix (const char *, const char *);
++static void do_not_print_archive_member (const char *, const char *);
++
++static void print_symbol_filename_bsd (bfd *, bfd *);
++static void print_symbol_filename_sysv (bfd *, bfd *);
++static void print_symbol_filename_posix (bfd *, bfd *);
++static void do_not_print_symbol_filename (bfd *, bfd *);
++
++static void print_symbol_info_bsd (struct extended_symbol_info *, bfd *);
++static void print_symbol_info_sysv (struct extended_symbol_info *, bfd *);
++static void print_symbol_info_posix (struct extended_symbol_info *, bfd *);
++static void just_print_symbol_name (struct extended_symbol_info *, bfd *);
++
++static void print_value (bfd *, bfd_vma);
++
++/* Support for different output formats.  */
++struct output_fns
++{
++  /* Print the name of an object file given on the command line.  */
++  void (*print_object_filename) (const char *);
++
++  /* Print the name of an archive file given on the command line.  */
++  void (*print_archive_filename) (const char *);
++
++  /* Print the name of an archive member file.  */
++  void (*print_archive_member) (const char *, const char *);
++
++  /* Print the name of the file (and archive, if there is one)
++     containing a symbol.  */
++  void (*print_symbol_filename) (bfd *, bfd *);
++
++  /* Print a line of information about a symbol.  */
++  void (*print_symbol_info) (struct extended_symbol_info *, bfd *);
++};
++
++/* Indices in `formats'.  */
++enum formats
++{
++  FORMAT_BSD = 0,
++  FORMAT_SYSV,
++  FORMAT_POSIX,
++  FORMAT_JUST_SYMBOLS,
++  FORMAT_MAX
++};
++
++#define FORMAT_DEFAULT FORMAT_BSD
++
++static struct output_fns formats[FORMAT_MAX] =
++{
++  {print_object_filename_bsd,
++   print_archive_filename_bsd,
++   print_archive_member_bsd,
++   print_symbol_filename_bsd,
++   print_symbol_info_bsd},
++  {print_object_filename_sysv,
++   print_archive_filename_sysv,
++   print_archive_member_sysv,
++   print_symbol_filename_sysv,
++   print_symbol_info_sysv},
++  {print_object_filename_posix,
++   print_archive_filename_posix,
++   print_archive_member_posix,
++   print_symbol_filename_posix,
++   print_symbol_info_posix},
++  {do_not_print_object_filename,
++   do_not_print_archive_filename,
++   do_not_print_archive_member,
++   do_not_print_symbol_filename,
++   just_print_symbol_name}
++};
++
++
++/* The output format to use.  */
++static struct output_fns *format = &formats[FORMAT_DEFAULT];
++static unsigned int print_format = FORMAT_DEFAULT;
++static const char *print_format_string = NULL;
++
++/* Command options.  */
++
++static int do_demangle = 0;	/* Pretty print C++ symbol names.  */
++static int external_only = 0;	/* Print external symbols only.  */
++static int defined_only = 0;	/* Print defined symbols only.  */
++static int no_sort = 0;		/* Don't sort; print syms in order found.  */
++static int print_debug_syms = 0;/* Print debugger-only symbols too.  */
++static int print_armap = 0;	/* Describe __.SYMDEF data in archive files.  */
++static int print_size = 0;	/* Print size of defined symbols.  */
++static int reverse_sort = 0;	/* Sort in downward(alpha or numeric) order.  */
++static int sort_numerically = 0;/* Sort in numeric rather than alpha order.  */
++static int sort_by_size = 0;	/* Sort by size of symbol.  */
++static int undefined_only = 0;	/* Print undefined symbols only.  */
++static int dynamic = 0;		/* Print dynamic symbols.  */
++static int show_version = 0;	/* Show the version number.  */
++static int show_synthetic = 0;	/* Display synthesized symbols too.  */
++static int line_numbers = 0;	/* Print line numbers for symbols.  */
++static int allow_special_symbols = 0;  /* Allow special symbols.  */
++static int with_symbol_versions = -1; /* Output symbol version information.  */
++static int quiet = 0;		/* Suppress "no symbols" diagnostic.  */
++
++/* The characters to use for global and local ifunc symbols.  */
++#if DEFAULT_F_FOR_IFUNC_SYMBOLS
++static const char * ifunc_type_chars = "Ff";
++#else
++static const char * ifunc_type_chars = NULL;
++#endif
++
++static int demangle_flags = DMGL_ANSI | DMGL_PARAMS;
++
++/* When to print the names of files.  Not mutually exclusive in SYSV format.  */
++static int filename_per_file = 0;	/* Once per file, on its own line.  */
++static int filename_per_symbol = 0;	/* Once per symbol, at start of line.  */
++
++static int print_width = 0;
++static int print_radix = 16;
++/* Print formats for printing stab info.  */
++static char other_format[] = "%02x";
++static char desc_format[] = "%04x";
++
++static char *target = NULL;
++#if BFD_SUPPORTS_PLUGINS
++static const char *plugin_target = "plugin";
++#else
++static const char *plugin_target = NULL;
++#endif
++
++/* Used to cache the line numbers for a BFD.  */
++static bfd *lineno_cache_bfd;
++static bfd *lineno_cache_rel_bfd;
++
++enum long_option_values
++{
++  OPTION_TARGET = 200,
++  OPTION_PLUGIN,
++  OPTION_SIZE_SORT,
++  OPTION_RECURSE_LIMIT,
++  OPTION_NO_RECURSE_LIMIT,
++  OPTION_IFUNC_CHARS,
++  OPTION_QUIET
++};
++
++static struct option long_options[] =
++{
++  {"debug-syms", no_argument, &print_debug_syms, 1},
++  {"demangle", optional_argument, 0, 'C'},
++  {"dynamic", no_argument, &dynamic, 1},
++  {"extern-only", no_argument, &external_only, 1},
++  {"format", required_argument, 0, 'f'},
++  {"help", no_argument, 0, 'h'},
++  {"ifunc-chars", required_argument, 0, OPTION_IFUNC_CHARS},
++  {"just-symbols", no_argument, 0, 'j'},
++  {"line-numbers", no_argument, 0, 'l'},
++  {"no-cplus", no_argument, &do_demangle, 0},  /* Linux compatibility.  */
++  {"no-demangle", no_argument, &do_demangle, 0},
++  {"no-recurse-limit", no_argument, NULL, OPTION_NO_RECURSE_LIMIT},
++  {"no-recursion-limit", no_argument, NULL, OPTION_NO_RECURSE_LIMIT},
++  {"no-sort", no_argument, 0, 'p'},
++  {"numeric-sort", no_argument, 0, 'n'},
++  {"plugin", required_argument, 0, OPTION_PLUGIN},
++  {"portability", no_argument, 0, 'P'},
++  {"print-armap", no_argument, &print_armap, 1},
++  {"print-file-name", no_argument, 0, 'o'},
++  {"print-size", no_argument, 0, 'S'},
++  {"quiet", no_argument, 0, OPTION_QUIET},
++  {"radix", required_argument, 0, 't'},
++  {"recurse-limit", no_argument, NULL, OPTION_RECURSE_LIMIT},
++  {"recursion-limit", no_argument, NULL, OPTION_RECURSE_LIMIT},
++  {"reverse-sort", no_argument, &reverse_sort, 1},
++  {"size-sort", no_argument, 0, OPTION_SIZE_SORT},
++  {"special-syms", no_argument, &allow_special_symbols, 1},
++  {"synthetic", no_argument, &show_synthetic, 1},
++  {"target", required_argument, 0, OPTION_TARGET},
++  {"defined-only", no_argument, &defined_only, 1},
++  {"undefined-only", no_argument, &undefined_only, 1},
++  {"version", no_argument, &show_version, 1},
++  {"with-symbol-versions", no_argument, &with_symbol_versions, 1},
++  {"without-symbol-versions", no_argument, &with_symbol_versions, 0},
++  {0, no_argument, 0, 0}
++};
++
++/* Some error-reporting functions.  */
++
++ATTRIBUTE_NORETURN static void
++usage (FILE *stream, int status)
++{
++  fprintf (stream, _("Usage: %s [option(s)] [file(s)]\n"), program_name);
++  fprintf (stream, _(" List symbols in [file(s)] (a.out by default).\n"));
++  fprintf (stream, _(" The options are:\n\
++  -a, --debug-syms       Display debugger-only symbols\n\
++  -A, --print-file-name  Print name of the input file before every symbol\n\
++  -B                     Same as --format=bsd\n\
++  -C, --demangle[=STYLE] Decode low-level symbol names into user-level names\n\
++                          The STYLE, if specified, can be `auto' (the default),\n\
++                          `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
++                          or `gnat'\n\
++      --no-demangle      Do not demangle low-level symbol names\n\
++      --recurse-limit    Enable a demangling recursion limit.  This is the default.\n\
++      --no-recurse-limit Disable a demangling recursion limit.\n\
++  -D, --dynamic          Display dynamic symbols instead of normal symbols\n\
++      --defined-only     Display only defined symbols\n\
++  -e                     (ignored)\n\
++  -f, --format=FORMAT    Use the output format FORMAT.  FORMAT can be `bsd',\n\
++                           `sysv', `posix' or 'just-symbols'.  The default is `bsd'\n\
++  -g, --extern-only      Display only external symbols\n\
++    --ifunc-chars=CHARS  Characters to use when displaying ifunc symbols\n\
++  -j, --just-symbols     Same as --format=just-symbols\n\
++  -l, --line-numbers     Use debugging information to find a filename and\n\
++                           line number for each symbol\n\
++  -n, --numeric-sort     Sort symbols numerically by address\n\
++  -o                     Same as -A\n\
++  -p, --no-sort          Do not sort the symbols\n\
++  -P, --portability      Same as --format=posix\n\
++  -r, --reverse-sort     Reverse the sense of the sort\n"));
++#if BFD_SUPPORTS_PLUGINS
++  fprintf (stream, _("\
++      --plugin NAME      Load the specified plugin\n"));
++#endif
++  fprintf (stream, _("\
++  -S, --print-size       Print size of defined symbols\n\
++  -s, --print-armap      Include index for symbols from archive members\n\
++      --quiet            Suppress \"no symbols\" diagnostic\n\
++      --size-sort        Sort symbols by size\n\
++      --special-syms     Include special symbols in the output\n\
++      --synthetic        Display synthetic symbols as well\n\
++  -t, --radix=RADIX      Use RADIX for printing symbol values\n\
++      --target=BFDNAME   Specify the target object format as BFDNAME\n\
++  -u, --undefined-only   Display only undefined symbols\n\
++      --with-symbol-versions  Display version strings after symbol names\n\
++  -X 32_64               (ignored)\n\
++  @FILE                  Read options from FILE\n\
++  -h, --help             Display this information\n\
++  -V, --version          Display this program's version number\n\
++\n"));
++  list_supported_targets (program_name, stream);
++  if (REPORT_BUGS_TO[0] && status == 0)
++    fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
++  exit (status);
++}
++
++/* Set the radix for the symbol value and size according to RADIX.  */
++
++static void
++set_print_radix (char *radix)
++{
++  switch (*radix)
++    {
++    case 'x': print_radix = 16; break;
++    case 'd': print_radix = 10; break;
++    case 'o': print_radix =  8; break;
++
++    default:
++      fatal (_("%s: invalid radix"), radix);
++    }
++
++  other_format[3] = desc_format[3] = *radix;
++}
++
++static void
++set_output_format (char *f)
++{
++  int i;
++
++  switch (*f)
++    {
++    case 'b':
++    case 'B':
++      i = FORMAT_BSD;
++      break;
++    case 'p':
++    case 'P':
++      i = FORMAT_POSIX;
++      break;
++    case 's':
++    case 'S':
++      i = FORMAT_SYSV;
++      break;
++    case 'j':
++    case 'J':
++      i = FORMAT_JUST_SYMBOLS;
++      break;
++    default:
++      fatal (_("%s: invalid output format"), f);
++    }
++  format = &formats[i];
++  print_format = i;
++}
++
++static const char *
++get_elf_symbol_type (unsigned int type)
++{
++  static char *bufp;
++  int n;
++
++  switch (type)
++    {
++    case STT_NOTYPE:   return "NOTYPE";
++    case STT_OBJECT:   return "OBJECT";
++    case STT_FUNC:     return "FUNC";
++    case STT_SECTION:  return "SECTION";
++    case STT_FILE:     return "FILE";
++    case STT_COMMON:   return "COMMON";
++    case STT_TLS:      return "TLS";
++    }
++
++  free (bufp);
++  if (type >= STT_LOPROC && type <= STT_HIPROC)
++    n = asprintf (&bufp, _("<processor specific>: %d"), type);
++  else if (type >= STT_LOOS && type <= STT_HIOS)
++    n = asprintf (&bufp, _("<OS specific>: %d"), type);
++  else
++    n = asprintf (&bufp, _("<unknown>: %d"), type);
++  if (n < 0)
++    fatal ("%s", xstrerror (errno));
++  return bufp;
++}
++
++static const char *
++get_coff_symbol_type (const struct internal_syment *sym)
++{
++  static char *bufp;
++  int n;
++
++  switch (sym->n_sclass)
++    {
++    case C_BLOCK: return "Block";
++    case C_FILE:  return "File";
++    case C_LINE:  return "Line";
++    }
++
++  if (!sym->n_type)
++    return "None";
++
++  switch (DTYPE(sym->n_type))
++    {
++    case DT_FCN: return "Function";
++    case DT_PTR: return "Pointer";
++    case DT_ARY: return "Array";
++    }
++
++  free (bufp);
++  n = asprintf (&bufp, _("<unknown>: %d/%d"), sym->n_sclass, sym->n_type);
++  if (n < 0)
++    fatal ("%s", xstrerror (errno));
++  return bufp;
++}
++
++/* Print symbol name NAME, read from ABFD, with printf format FORM,
++   demangling it if requested.  */
++
++static void
++print_symname (const char *form, struct extended_symbol_info *info,
++	       const char *name, bfd *abfd)
++{
++  char *alloc = NULL;
++  char *atver = NULL;
++
++  if (name == NULL)
++    name = info->sinfo->name;
++  if (!with_symbol_versions
++      && bfd_get_flavour (abfd) == bfd_target_elf_flavour)
++    {
++      atver = strchr (name, '@');
++      if (atver)
++	*atver = 0;
++    }
++  if (do_demangle && *name)
++    {
++      alloc = bfd_demangle (abfd, name, demangle_flags);
++      if (alloc != NULL)
++	name = alloc;
++    }
++
++  if (info != NULL && info->elfinfo && with_symbol_versions)
++    {
++      const char *version_string;
++      bool hidden;
++
++      version_string
++	= bfd_get_symbol_version_string (abfd, &info->elfinfo->symbol,
++					 false, &hidden);
++      if (version_string && version_string[0])
++	{
++	  const char *at = "@@";
++	  if (hidden || bfd_is_und_section (info->elfinfo->symbol.section))
++	    at = "@";
++	  alloc = reconcat (alloc, name, at, version_string, NULL);
++	  if (alloc != NULL)
++	    name = alloc;
++	}
++    }
++  printf (form, name);
++  if (atver)
++    *atver = '@';
++  free (alloc);
++}
++
++static void
++print_symdef_entry (bfd *abfd)
++{
++  symindex idx = BFD_NO_MORE_SYMBOLS;
++  carsym *thesym;
++  bool everprinted = false;
++
++  for (idx = bfd_get_next_mapent (abfd, idx, &thesym);
++       idx != BFD_NO_MORE_SYMBOLS;
++       idx = bfd_get_next_mapent (abfd, idx, &thesym))
++    {
++      bfd *elt;
++      if (!everprinted)
++	{
++	  printf (_("\nArchive index:\n"));
++	  everprinted = true;
++	}
++      elt = bfd_get_elt_at_index (abfd, idx);
++      if (elt == NULL)
++	bfd_fatal ("bfd_get_elt_at_index");
++      if (thesym->name != (char *) NULL)
++	{
++	  print_symname ("%s", NULL, thesym->name, abfd);
++	  printf (" in %s\n", bfd_get_filename (elt));
++	}
++    }
++}
++
++
++/* True when we can report missing plugin error.  */
++bool report_plugin_err = true;
++
++/* Choose which symbol entries to print;
++   compact them downward to get rid of the rest.
++   Return the number of symbols to be printed.  */
++
++static long
++filter_symbols (bfd *abfd, bool is_dynamic, void *minisyms,
++		long symcount, unsigned int size)
++{
++  bfd_byte *from, *fromend, *to;
++  asymbol *store;
++
++  store = bfd_make_empty_symbol (abfd);
++  if (store == NULL)
++    bfd_fatal (bfd_get_filename (abfd));
++
++  from = (bfd_byte *) minisyms;
++  fromend = from + symcount * size;
++  to = (bfd_byte *) minisyms;
++
++  for (; from < fromend; from += size)
++    {
++      int keep = 0;
++      asymbol *sym;
++
++      PROGRESS (1);
++
++      sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, (const void *) from, store);
++      if (sym == NULL)
++	bfd_fatal (bfd_get_filename (abfd));
++
++      if (sym->name[0] == '_'
++	  && sym->name[1] == '_'
++	  && strcmp (sym->name + (sym->name[2] == '_'), "__gnu_lto_slim") == 0
++	  && report_plugin_err)
++	{
++	  report_plugin_err = false;
++	  non_fatal (_("%s: plugin needed to handle lto object"),
++		     bfd_get_filename (abfd));
++	}
++
++      if (undefined_only)
++	keep = bfd_is_und_section (sym->section);
++      else if (external_only)
++	/* PR binutls/12753: Unique symbols are global too.  */
++	keep = ((sym->flags & (BSF_GLOBAL
++			       | BSF_WEAK
++			       | BSF_GNU_UNIQUE)) != 0
++		|| bfd_is_und_section (sym->section)
++		|| bfd_is_com_section (sym->section));
++      else
++	keep = 1;
++
++      if (keep
++	  && ! print_debug_syms
++	  && (sym->flags & BSF_DEBUGGING) != 0)
++	keep = 0;
++
++      if (keep
++	  && sort_by_size
++	  && (bfd_is_abs_section (sym->section)
++	      || bfd_is_und_section (sym->section)))
++	keep = 0;
++
++      if (keep
++	  && defined_only)
++	{
++	  if (bfd_is_und_section (sym->section))
++	    keep = 0;
++	}
++
++      if (keep
++	  && bfd_is_target_special_symbol (abfd, sym)
++	  && ! allow_special_symbols)
++	keep = 0;
++
++      if (keep)
++	{
++	  if (to != from)
++	    memcpy (to, from, size);
++	  to += size;
++	}
++    }
++
++  return (to - (bfd_byte *) minisyms) / size;
++}
++
++/* These globals are used to pass information into the sorting
++   routines.  */
++static bfd *sort_bfd;
++static bool sort_dynamic;
++static asymbol *sort_x;
++static asymbol *sort_y;
++
++/* Symbol-sorting predicates */
++#define valueof(x) ((x)->section->vma + (x)->value)
++
++/* Numeric sorts.  Undefined symbols are always considered "less than"
++   defined symbols with zero values.  Common symbols are not treated
++   specially -- i.e., their sizes are used as their "values".  */
++
++static int
++non_numeric_forward (const void *P_x, const void *P_y)
++{
++  asymbol *x, *y;
++  const char *xn, *yn;
++
++  x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
++  y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
++  if (x == NULL || y == NULL)
++    bfd_fatal (bfd_get_filename (sort_bfd));
++
++  xn = bfd_asymbol_name (x);
++  yn = bfd_asymbol_name (y);
++
++  if (yn == NULL)
++    return xn != NULL;
++  if (xn == NULL)
++    return -1;
++
++  /* Solaris 2.5 has a bug in strcoll.
++     strcoll returns invalid values when confronted with empty strings.  */
++  if (*yn == '\0')
++    return *xn != '\0';
++  if (*xn == '\0')
++    return -1;
++
++  return strcoll (xn, yn);
++}
++
++static int
++non_numeric_reverse (const void *x, const void *y)
++{
++  return - non_numeric_forward (x, y);
++}
++
++static int
++numeric_forward (const void *P_x, const void *P_y)
++{
++  asymbol *x, *y;
++  asection *xs, *ys;
++
++  x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
++  y =  bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
++  if (x == NULL || y == NULL)
++    bfd_fatal (bfd_get_filename (sort_bfd));
++
++  xs = bfd_asymbol_section (x);
++  ys = bfd_asymbol_section (y);
++
++  if (bfd_is_und_section (xs))
++    {
++      if (! bfd_is_und_section (ys))
++	return -1;
++    }
++  else if (bfd_is_und_section (ys))
++    return 1;
++  else if (valueof (x) != valueof (y))
++    return valueof (x) < valueof (y) ? -1 : 1;
++
++  return non_numeric_forward (P_x, P_y);
++}
++
++static int
++numeric_reverse (const void *x, const void *y)
++{
++  return - numeric_forward (x, y);
++}
++
++static int (*(sorters[2][2])) (const void *, const void *) =
++{
++  { non_numeric_forward, non_numeric_reverse },
++  { numeric_forward, numeric_reverse }
++};
++
++/* This sort routine is used by sort_symbols_by_size.  It is similar
++   to numeric_forward, but when symbols have the same value it sorts
++   by section VMA.  This simplifies the sort_symbols_by_size code
++   which handles symbols at the end of sections.  Also, this routine
++   tries to sort file names before other symbols with the same value.
++   That will make the file name have a zero size, which will make
++   sort_symbols_by_size choose the non file name symbol, leading to
++   more meaningful output.  For similar reasons, this code sorts
++   gnu_compiled_* and gcc2_compiled before other symbols with the same
++   value.  */
++
++static int
++size_forward1 (const void *P_x, const void *P_y)
++{
++  asymbol *x, *y;
++  asection *xs, *ys;
++  const char *xn, *yn;
++  size_t xnl, ynl;
++  int xf, yf;
++
++  x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
++  y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
++  if (x == NULL || y == NULL)
++    bfd_fatal (bfd_get_filename (sort_bfd));
++
++  xs = bfd_asymbol_section (x);
++  ys = bfd_asymbol_section (y);
++
++  if (bfd_is_und_section (xs))
++    abort ();
++  if (bfd_is_und_section (ys))
++    abort ();
++
++  if (valueof (x) != valueof (y))
++    return valueof (x) < valueof (y) ? -1 : 1;
++
++  if (xs->vma != ys->vma)
++    return xs->vma < ys->vma ? -1 : 1;
++
++  xn = bfd_asymbol_name (x);
++  yn = bfd_asymbol_name (y);
++  xnl = strlen (xn);
++  ynl = strlen (yn);
++
++  /* The symbols gnu_compiled and gcc2_compiled convey even less
++     information than the file name, so sort them out first.  */
++
++  xf = (strstr (xn, "gnu_compiled") != NULL
++	|| strstr (xn, "gcc2_compiled") != NULL);
++  yf = (strstr (yn, "gnu_compiled") != NULL
++	|| strstr (yn, "gcc2_compiled") != NULL);
++
++  if (xf && ! yf)
++    return -1;
++  if (! xf && yf)
++    return 1;
++
++  /* We use a heuristic for the file name.  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')))
++
++  xf = file_symbol (x, xn, xnl);
++  yf = file_symbol (y, yn, ynl);
++
++  if (xf && ! yf)
++    return -1;
++  if (! xf && yf)
++    return 1;
++
++  return non_numeric_forward (P_x, P_y);
++}
++
++/* This sort routine is used by sort_symbols_by_size.  It is sorting
++   an array of size_sym structures into size order.  */
++
++static int
++size_forward2 (const void *P_x, const void *P_y)
++{
++  const struct size_sym *x = (const struct size_sym *) P_x;
++  const struct size_sym *y = (const struct size_sym *) P_y;
++
++  if (x->size < y->size)
++    return reverse_sort ? 1 : -1;
++  else if (x->size > y->size)
++    return reverse_sort ? -1 : 1;
++  else
++    return sorters[0][reverse_sort] (x->minisym, y->minisym);
++}
++
++/* Sort the symbols by size.  ELF provides a size but for other formats
++   we have to make a guess by assuming that the difference between the
++   address of a symbol and the address of the next higher symbol is the
++   size.  */
++
++static long
++sort_symbols_by_size (bfd *abfd, bool is_dynamic, void *minisyms,
++		      long symcount, unsigned int size,
++		      struct size_sym **symsizesp)
++{
++  struct size_sym *symsizes;
++  bfd_byte *from, *fromend;
++  asymbol *sym = NULL;
++  asymbol *store_sym, *store_next;
++
++  qsort (minisyms, symcount, size, size_forward1);
++
++  /* We are going to return a special set of symbols and sizes to
++     print.  */
++  symsizes = (struct size_sym *) xmalloc (symcount * sizeof (struct size_sym));
++  *symsizesp = symsizes;
++
++  /* Note that filter_symbols has already removed all absolute and
++     undefined symbols.  Here we remove all symbols whose size winds
++     up as zero.  */
++  from = (bfd_byte *) minisyms;
++  fromend = from + symcount * size;
++
++  store_sym = sort_x;
++  store_next = sort_y;
++
++  if (from < fromend)
++    {
++      sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, (const void *) from,
++				      store_sym);
++      if (sym == NULL)
++	bfd_fatal (bfd_get_filename (abfd));
++    }
++
++  for (; from < fromend; from += size)
++    {
++      asymbol *next;
++      asection *sec;
++      bfd_vma sz;
++      asymbol *temp;
++
++      if (from + size < fromend)
++	{
++	  next = bfd_minisymbol_to_symbol (abfd,
++					   is_dynamic,
++					   (const void *) (from + size),
++					   store_next);
++	  if (next == NULL)
++	    bfd_fatal (bfd_get_filename (abfd));
++	}
++      else
++	next = NULL;
++
++      sec = bfd_asymbol_section (sym);
++
++      /* Synthetic symbols don't have a full type set of data available, thus
++	 we can't rely on that information for the symbol size.  Ditto for
++	 bfd/section.c:global_syms like *ABS*.  */
++      if ((sym->flags & (BSF_SECTION_SYM | BSF_SYNTHETIC)) == 0
++	  && bfd_get_flavour (abfd) == bfd_target_elf_flavour)
++	sz = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
++      else if ((sym->flags & (BSF_SECTION_SYM | BSF_SYNTHETIC)) == 0
++	       && bfd_is_com_section (sec))
++	sz = sym->value;
++      else
++	{
++	  if (from + size < fromend
++	      && sec == bfd_asymbol_section (next))
++	    sz = valueof (next) - valueof (sym);
++	  else
++	    sz = (bfd_section_vma (sec)
++		  + bfd_section_size (sec)
++		  - valueof (sym));
++	}
++
++      if (sz != 0)
++	{
++	  symsizes->minisym = (const void *) from;
++	  symsizes->size = sz;
++	  ++symsizes;
++	}
++
++      sym = next;
++
++      temp = store_sym;
++      store_sym = store_next;
++      store_next = temp;
++    }
++
++  symcount = symsizes - *symsizesp;
++
++  /* We must now sort again by size.  */
++  qsort ((void *) *symsizesp, symcount, sizeof (struct size_sym), size_forward2);
++
++  return symcount;
++}
++
++/* This function is used to get the relocs for a particular section.
++   It is called via bfd_map_over_sections.  */
++
++static void
++get_relocs (bfd *abfd, asection *sec, void *dataarg)
++{
++  struct get_relocs_info *data = (struct get_relocs_info *) dataarg;
++
++  *data->secs = sec;
++
++  if ((sec->flags & SEC_RELOC) == 0)
++    {
++      *data->relocs = NULL;
++      *data->relcount = 0;
++    }
++  else
++    {
++      long relsize;
++
++      relsize = bfd_get_reloc_upper_bound (abfd, sec);
++      if (relsize < 0)
++	bfd_fatal (bfd_get_filename (abfd));
++
++      *data->relocs = (arelent **) xmalloc (relsize);
++      *data->relcount = bfd_canonicalize_reloc (abfd, sec, *data->relocs,
++						data->syms);
++      if (*data->relcount < 0)
++	bfd_fatal (bfd_get_filename (abfd));
++    }
++
++  ++data->secs;
++  ++data->relocs;
++  ++data->relcount;
++}
++
++/* Print a single symbol.  */
++
++static void
++print_symbol (bfd *        abfd,
++	      asymbol *    sym,
++	      bfd_vma      ssize,
++	      bfd *        archive_bfd)
++{
++  symbol_info syminfo;
++  struct extended_symbol_info info;
++
++  PROGRESS (1);
++
++  format->print_symbol_filename (archive_bfd, abfd);
++
++  bfd_get_symbol_info (abfd, sym, &syminfo);
++
++  /* PR 22967 - Distinguish between local and global ifunc symbols.  */
++  if (syminfo.type == 'i'
++      && sym->flags & BSF_GNU_INDIRECT_FUNCTION)
++    {
++      if (ifunc_type_chars == NULL || ifunc_type_chars[0] == 0)
++	; /* Change nothing.  */
++      else if (sym->flags & BSF_GLOBAL) 
++	syminfo.type = ifunc_type_chars[0];
++      else if (ifunc_type_chars[1] != 0)
++	syminfo.type = ifunc_type_chars[1];
++    }
++
++  info.sinfo = &syminfo;
++  info.ssize = ssize;
++  /* Synthetic symbols do not have a full symbol type set of data available.
++     Nor do bfd/section.c:global_syms like *ABS*.  */
++  if ((sym->flags & (BSF_SECTION_SYM | BSF_SYNTHETIC)) != 0)
++    {
++      info.elfinfo = NULL;
++      info.coffinfo = NULL;
++    }
++  else
++    {
++      info.elfinfo = elf_symbol_from (sym);
++      info.coffinfo = coff_symbol_from (sym);
++    }
++
++  format->print_symbol_info (&info, abfd);
++
++  if (line_numbers)
++    {
++      static asymbol **syms;
++      static long symcount;
++      const char *filename, *functionname;
++      unsigned int lineno;
++
++      /* We need to get the canonical symbols in order to call
++         bfd_find_nearest_line.  This is inefficient, but, then, you
++         don't have to use --line-numbers.  */
++      if (abfd != lineno_cache_bfd && syms != NULL)
++	{
++	  free (syms);
++	  syms = NULL;
++	}
++      if (syms == NULL)
++	{
++	  long symsize;
++
++	  symsize = bfd_get_symtab_upper_bound (abfd);
++	  if (symsize < 0)
++	    bfd_fatal (bfd_get_filename (abfd));
++	  syms = (asymbol **) xmalloc (symsize);
++	  symcount = bfd_canonicalize_symtab (abfd, syms);
++	  if (symcount < 0)
++	    bfd_fatal (bfd_get_filename (abfd));
++	  lineno_cache_bfd = abfd;
++	}
++
++      if (bfd_is_und_section (bfd_asymbol_section (sym)))
++	{
++	  static asection **secs;
++	  static arelent ***relocs;
++	  static long *relcount;
++	  static unsigned int seccount;
++	  unsigned int i;
++	  const char *symname;
++
++	  /* For an undefined symbol, we try to find a reloc for the
++             symbol, and print the line number of the reloc.  */
++	  if (abfd != lineno_cache_rel_bfd && relocs != NULL)
++	    {
++	      for (i = 0; i < seccount; i++)
++		if (relocs[i] != NULL)
++		  free (relocs[i]);
++	      free (secs);
++	      free (relocs);
++	      free (relcount);
++	      secs = NULL;
++	      relocs = NULL;
++	      relcount = NULL;
++	    }
++
++	  if (relocs == NULL)
++	    {
++	      struct get_relocs_info rinfo;
++
++	      seccount = bfd_count_sections (abfd);
++
++	      secs = (asection **) xmalloc (seccount * sizeof *secs);
++	      relocs = (arelent ***) xmalloc (seccount * sizeof *relocs);
++	      relcount = (long *) xmalloc (seccount * sizeof *relcount);
++
++	      rinfo.secs = secs;
++	      rinfo.relocs = relocs;
++	      rinfo.relcount = relcount;
++	      rinfo.syms = syms;
++	      bfd_map_over_sections (abfd, get_relocs, (void *) &rinfo);
++	      lineno_cache_rel_bfd = abfd;
++	    }
++
++	  symname = bfd_asymbol_name (sym);
++	  for (i = 0; i < seccount; i++)
++	    {
++	      long j;
++
++	      for (j = 0; j < relcount[i]; j++)
++		{
++		  arelent *r;
++
++		  r = relocs[i][j];
++		  if (r->sym_ptr_ptr != NULL
++		      && (*r->sym_ptr_ptr)->section == sym->section
++		      && (*r->sym_ptr_ptr)->value == sym->value
++		      && strcmp (symname,
++				 bfd_asymbol_name (*r->sym_ptr_ptr)) == 0
++		      && bfd_find_nearest_line (abfd, secs[i], syms,
++						r->address, &filename,
++						&functionname, &lineno)
++		      && filename != NULL)
++		    {
++		      /* We only print the first one we find.  */
++		      printf ("\t%s:%u", filename, lineno);
++		      i = seccount;
++		      break;
++		    }
++		}
++	    }
++	}
++      else if (bfd_asymbol_section (sym)->owner == abfd)
++	{
++	  if ((bfd_find_line (abfd, syms, sym, &filename, &lineno)
++	       || bfd_find_nearest_line (abfd, bfd_asymbol_section (sym),
++					 syms, sym->value, &filename,
++					 &functionname, &lineno))
++	      && filename != NULL
++	      && lineno != 0)
++	    printf ("\t%s:%u", filename, lineno);
++	}
++    }
++
++  putchar ('\n');
++}
++
++/* Print the symbols when sorting by size.  */
++
++static void
++print_size_symbols (bfd *abfd,
++		    bool is_dynamic,
++		    struct size_sym *symsizes,
++		    long symcount,
++		    bfd *archive_bfd)
++{
++  asymbol *store;
++  struct size_sym *from;
++  struct size_sym *fromend;
++
++  store = bfd_make_empty_symbol (abfd);
++  if (store == NULL)
++    bfd_fatal (bfd_get_filename (abfd));
++
++  from = symsizes;
++  fromend = from + symcount;
++
++  for (; from < fromend; from++)
++    {
++      asymbol *sym;
++
++      sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, from->minisym, store);
++      if (sym == NULL)
++	bfd_fatal (bfd_get_filename (abfd));
++
++      print_symbol (abfd, sym, from->size, archive_bfd);
++    }
++}
++
++
++/* Print the symbols of ABFD that are held in MINISYMS.
++
++   If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD.
++
++   SYMCOUNT is the number of symbols in MINISYMS.
++
++   SIZE is the size of a symbol in MINISYMS.  */
++
++static void
++print_symbols (bfd *abfd,
++	       bool is_dynamic,
++	       void *minisyms,
++	       long symcount,
++	       unsigned int size,
++	       bfd *archive_bfd)
++{
++  asymbol *store;
++  bfd_byte *from;
++  bfd_byte *fromend;
++
++  store = bfd_make_empty_symbol (abfd);
++  if (store == NULL)
++    bfd_fatal (bfd_get_filename (abfd));
++
++  from = (bfd_byte *) minisyms;
++  fromend = from + symcount * size;
++
++  for (; from < fromend; from += size)
++    {
++      asymbol *sym;
++
++      sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, from, store);
++      if (sym == NULL)
++	bfd_fatal (bfd_get_filename (abfd));
++
++      print_symbol (abfd, sym, (bfd_vma) 0, archive_bfd);
++    }
++}
++
++/* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD.  */
++
++static void
++display_rel_file (bfd *abfd, bfd *archive_bfd)
++{
++  long symcount;
++  void *minisyms;
++  unsigned int size;
++  struct size_sym *symsizes;
++  asymbol *synthsyms = NULL;
++
++  if (! dynamic)
++    {
++      if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
++	{
++	  if (!quiet)
++	    non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
++	  return;
++	}
++    }
++
++  symcount = bfd_read_minisymbols (abfd, dynamic, &minisyms, &size);
++  if (symcount < 0)
++    {
++      if (dynamic && bfd_get_error () == bfd_error_no_symbols)
++	{
++	  if (!quiet)
++	    non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
++	  return;
++	}
++
++      bfd_fatal (bfd_get_filename (abfd));
++    }
++
++  if (symcount == 0)
++    {
++      if (!quiet)
++	non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
++      return;
++    }
++
++  if (show_synthetic && size == sizeof (asymbol *))
++    {
++      asymbol **static_syms = NULL;
++      asymbol **dyn_syms = NULL;
++      long static_count = 0;
++      long dyn_count = 0;
++      long synth_count;
++
++      if (dynamic)
++	{
++	  dyn_count = symcount;
++	  dyn_syms = (asymbol **) minisyms;
++	}
++      else
++	{
++	  long storage = bfd_get_dynamic_symtab_upper_bound (abfd);
++
++	  static_count = symcount;
++	  static_syms = (asymbol **) minisyms;
++
++	  if (storage > 0)
++	    {
++	      dyn_syms = (asymbol **) xmalloc (storage);
++	      dyn_count = bfd_canonicalize_dynamic_symtab (abfd, dyn_syms);
++	      if (dyn_count < 0)
++		bfd_fatal (bfd_get_filename (abfd));
++	    }
++	}
++
++      synth_count = bfd_get_synthetic_symtab (abfd, static_count, static_syms,
++					      dyn_count, dyn_syms, &synthsyms);
++      if (synth_count > 0)
++	{
++	  asymbol **symp;
++	  long i;
++
++	  minisyms = xrealloc (minisyms,
++			       (symcount + synth_count + 1) * sizeof (*symp));
++	  symp = (asymbol **) minisyms + symcount;
++	  for (i = 0; i < synth_count; i++)
++	    *symp++ = synthsyms + i;
++	  *symp = 0;
++	  symcount += synth_count;
++	}
++      if (!dynamic && dyn_syms != NULL)
++	free (dyn_syms);
++    }
++
++  /* lto_slim_object is set to false when a bfd is loaded with a compiler
++     LTO plugin.  */
++  if (abfd->lto_slim_object)
++    {
++      report_plugin_err = false;
++      non_fatal (_("%s: plugin needed to handle lto object"),
++		 bfd_get_filename (abfd));
++    }
++
++  /* Discard the symbols we don't want to print.
++     It's OK to do this in place; we'll free the storage anyway
++     (after printing).  */
++
++  symcount = filter_symbols (abfd, dynamic, minisyms, symcount, size);
++
++  symsizes = NULL;
++  if (! no_sort)
++    {
++      sort_bfd = abfd;
++      sort_dynamic = dynamic;
++      sort_x = bfd_make_empty_symbol (abfd);
++      sort_y = bfd_make_empty_symbol (abfd);
++      if (sort_x == NULL || sort_y == NULL)
++	bfd_fatal (bfd_get_filename (abfd));
++
++      if (! sort_by_size)
++	qsort (minisyms, symcount, size,
++	       sorters[sort_numerically][reverse_sort]);
++      else
++	symcount = sort_symbols_by_size (abfd, dynamic, minisyms, symcount,
++					 size, &symsizes);
++    }
++
++  if (! sort_by_size)
++    print_symbols (abfd, dynamic, minisyms, symcount, size, archive_bfd);
++  else
++    print_size_symbols (abfd, dynamic, symsizes, symcount, archive_bfd);
++
++  if (synthsyms)
++    free (synthsyms);
++  free (minisyms);
++  free (symsizes);
++}
++
++/* Construct a formatting string for printing symbol values.  */
++
++static const char *
++get_print_format (void)
++{
++  const char * padding;
++  if (print_format == FORMAT_POSIX || print_format == FORMAT_JUST_SYMBOLS)
++    {
++      /* POSIX compatible output does not have any padding.  */
++      padding = "";
++    }
++  else if (print_width == 32)
++    {
++      padding ="08";
++    }
++  else /* print_width == 64 */
++    {
++      padding = "016";
++    }
++
++  const char * length = "l";
++  if (print_width == 64)
++    {
++#if BFD_HOST_64BIT_LONG
++      ;
++#elif BFD_HOST_64BIT_LONG_LONG
++#ifndef __MSVCRT__
++      length = "ll";
++#else
++      length = "I64";
++#endif
++#endif
++    }
++
++  const char * radix = NULL;
++  switch (print_radix)
++    {
++    case 8:  radix = "o"; break;
++    case 10: radix = "d"; break;
++    case 16: radix = "x"; break;
++    }
++
++  return concat ("%", padding, length, radix, NULL);
++}
++
++static void
++set_print_width (bfd *file)
++{
++  print_width = bfd_get_arch_size (file);
++
++  if (print_width == -1)
++    {
++      /* PR binutils/4292
++	 Guess the target's bitsize based on its name.
++	 We assume here than any 64-bit format will include
++	 "64" somewhere in its name.  The only known exception
++	 is the MMO object file format.  */
++      if (strstr (bfd_get_target (file), "64") != NULL
++	  || strcmp (bfd_get_target (file), "mmo") == 0)
++	print_width = 64;
++      else
++	print_width = 32;
++    }
++  free ((char *) print_format_string);
++  print_format_string = get_print_format ();
++}
++
++static void
++display_archive (bfd *file)
++{
++  bfd *arfile = NULL;
++  bfd *last_arfile = NULL;
++  char **matching;
++
++  format->print_archive_filename (bfd_get_filename (file));
++
++  if (print_armap)
++    print_symdef_entry (file);
++
++  for (;;)
++    {
++      PROGRESS (1);
++
++      arfile = bfd_openr_next_archived_file (file, arfile);
++
++      if (arfile == NULL)
++	{
++	  if (bfd_get_error () != bfd_error_no_more_archived_files)
++	    bfd_fatal (bfd_get_filename (file));
++	  break;
++	}
++
++      if (bfd_check_format_matches (arfile, bfd_object, &matching))
++	{
++	  set_print_width (arfile);
++	  format->print_archive_member (bfd_get_filename (file),
++					bfd_get_filename (arfile));
++	  display_rel_file (arfile, file);
++	}
++      else
++	{
++	  bfd_nonfatal (bfd_get_filename (arfile));
++	  if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
++	    {
++	      list_matching_formats (matching);
++	      free (matching);
++	    }
++	}
++
++      if (last_arfile != NULL)
++	{
++	  bfd_close (last_arfile);
++	  lineno_cache_bfd = NULL;
++	  lineno_cache_rel_bfd = NULL;
++	  if (arfile == last_arfile)
++	    return;
++	}
++      last_arfile = arfile;
++    }
++
++  if (last_arfile != NULL)
++    {
++      bfd_close (last_arfile);
++      lineno_cache_bfd = NULL;
++      lineno_cache_rel_bfd = NULL;
++    }
++}
++
++static bool
++display_file (char *filename)
++{
++  bool retval = true;
++  bfd *file;
++  char **matching;
++
++  if (get_file_size (filename) < 1)
++    return false;
++
++  file = bfd_openr (filename, target ? target : plugin_target);
++  if (file == NULL)
++    {
++      bfd_nonfatal (filename);
++      return false;
++    }
++
++  /* If printing line numbers, decompress the debug sections.  */
++  if (line_numbers)
++    file->flags |= BFD_DECOMPRESS;
++
++  if (bfd_check_format (file, bfd_archive))
++    {
++      display_archive (file);
++    }
++  else if (bfd_check_format_matches (file, bfd_object, &matching))
++    {
++      set_print_width (file);
++      format->print_object_filename (filename);
++      display_rel_file (file, NULL);
++    }
++  else
++    {
++      bfd_nonfatal (filename);
++      if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
++	{
++	  list_matching_formats (matching);
++	  free (matching);
++	}
++      retval = false;
++    }
++
++  if (!bfd_close (file))
++    bfd_fatal (filename);
++
++  lineno_cache_bfd = NULL;
++  lineno_cache_rel_bfd = NULL;
++
++  return retval;
++}
++
++/* The following 3 groups of functions are called unconditionally,
++   once at the start of processing each file of the appropriate type.
++   They should check `filename_per_file' and `filename_per_symbol',
++   as appropriate for their output format, to determine whether to
++   print anything.  */
++
++/* Print the name of an object file given on the command line.  */
++
++static void
++print_object_filename_bsd (const char *filename)
++{
++  if (filename_per_file && !filename_per_symbol)
++    printf ("\n%s:\n", filename);
++}
++
++static void
++print_object_filename_sysv (const char *filename)
++{
++  if (undefined_only)
++    printf (_("\n\nUndefined symbols from %s:\n\n"), filename);
++  else
++    printf (_("\n\nSymbols from %s:\n\n"), filename);
++  if (print_width == 32)
++    printf (_("\
++Name                  Value   Class        Type         Size     Line  Section\n\n"));
++  else
++    printf (_("\
++Name                  Value           Class        Type         Size             Line  Section\n\n"));
++}
++
++static void
++print_object_filename_posix (const char *filename)
++{
++  if (filename_per_file && !filename_per_symbol)
++    printf ("%s:\n", filename);
++}
++
++static void
++do_not_print_object_filename (const char *filename ATTRIBUTE_UNUSED)
++{
++}
++
++/* Print the name of an archive file given on the command line.  */
++
++static void
++print_archive_filename_bsd (const char *filename)
++{
++  if (filename_per_file)
++    printf ("\n%s:\n", filename);
++}
++
++static void
++print_archive_filename_sysv (const char *filename ATTRIBUTE_UNUSED)
++{
++}
++
++static void
++print_archive_filename_posix (const char *filename ATTRIBUTE_UNUSED)
++{
++}
++
++static void
++do_not_print_archive_filename (const char *filename ATTRIBUTE_UNUSED)
++{
++}
++
++/* Print the name of an archive member file.  */
++
++static void
++print_archive_member_bsd (const char *archive ATTRIBUTE_UNUSED,
++			  const char *filename)
++{
++  if (!filename_per_symbol)
++    printf ("\n%s:\n", filename);
++}
++
++static void
++print_archive_member_sysv (const char *archive, const char *filename)
++{
++  if (undefined_only)
++    printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive, filename);
++  else
++    printf (_("\n\nSymbols from %s[%s]:\n\n"), archive, filename);
++  if (print_width == 32)
++    printf (_("\
++Name                  Value   Class        Type         Size     Line  Section\n\n"));
++  else
++    printf (_("\
++Name                  Value           Class        Type         Size             Line  Section\n\n"));
++}
++
++static void
++print_archive_member_posix (const char *archive, const char *filename)
++{
++  if (!filename_per_symbol)
++    printf ("%s[%s]:\n", archive, filename);
++}
++
++static void
++do_not_print_archive_member (const char *archive ATTRIBUTE_UNUSED,
++			     const char *filename ATTRIBUTE_UNUSED)
++{
++}
++
++
++/* Print the name of the file (and archive, if there is one)
++   containing a symbol.  */
++
++static void
++print_symbol_filename_bsd (bfd *archive_bfd, bfd *abfd)
++{
++  if (filename_per_symbol)
++    {
++      if (archive_bfd)
++	printf ("%s:", bfd_get_filename (archive_bfd));
++      printf ("%s:", bfd_get_filename (abfd));
++    }
++}
++
++static void
++print_symbol_filename_sysv (bfd *archive_bfd, bfd *abfd)
++{
++  if (filename_per_symbol)
++    {
++      if (archive_bfd)
++	printf ("%s:", bfd_get_filename (archive_bfd));
++      printf ("%s:", bfd_get_filename (abfd));
++    }
++}
++
++static void
++print_symbol_filename_posix (bfd *archive_bfd, bfd *abfd)
++{
++  if (filename_per_symbol)
++    {
++      if (archive_bfd)
++	printf ("%s[%s]: ", bfd_get_filename (archive_bfd),
++		bfd_get_filename (abfd));
++      else
++	printf ("%s: ", bfd_get_filename (abfd));
++    }
++}
++
++static void
++do_not_print_symbol_filename (bfd *archive_bfd ATTRIBUTE_UNUSED,
++			      bfd *abfd ATTRIBUTE_UNUSED)
++{
++}
++
++
++/* Print a symbol value.  */
++
++static void
++print_value (bfd *abfd ATTRIBUTE_UNUSED, bfd_vma val)
++{
++  switch (print_width)
++    {
++    case 32:
++      printf (print_format_string, (unsigned long) val);
++      break;
++
++    case 64:
++#if BFD_HOST_64BIT_LONG || BFD_HOST_64BIT_LONG_LONG
++      printf (print_format_string, val);
++#else
++      /* We have a 64 bit value to print, but the host is only 32 bit.  */
++      if (print_radix == 16)
++	bfd_fprintf_vma (abfd, stdout, val);
++      else
++	{
++	  char buf[30];
++	  char *s;
++
++	  s = buf + sizeof buf;
++	  *--s = '\0';
++	  while (val > 0)
++	    {
++	      *--s = (val % print_radix) + '0';
++	      val /= print_radix;
++	    }
++	  while ((buf + sizeof buf - 1) - s < 16)
++	    *--s = '0';
++	  printf ("%s", s);
++	}
++#endif
++      break;
++
++    default:
++      fatal (_("Print width has not been initialized (%d)"), print_width);
++      break;
++    }
++}
++
++/* Print a line of information about a symbol.  */
++
++static void
++print_symbol_info_bsd (struct extended_symbol_info *info, bfd *abfd)
++{
++  if (bfd_is_undefined_symclass (SYM_TYPE (info)))
++    {
++      if (print_width == 64)
++	printf ("        ");
++      printf ("        ");
++    }
++  else
++    {
++      /* Normally we print the value of the symbol.  If we are printing the
++	 size or sorting by size then we print its size, except for the
++	 (weird) special case where both flags are defined, in which case we
++	 print both values.  This conforms to documented behaviour.  */
++      if (sort_by_size && !print_size)
++	print_value (abfd, SYM_SIZE (info));
++      else
++	print_value (abfd, SYM_VALUE (info));
++      if (print_size && SYM_SIZE (info))
++	{
++	  printf (" ");
++	  print_value (abfd, SYM_SIZE (info));
++	}
++    }
++
++  printf (" %c", SYM_TYPE (info));
++
++  if (SYM_TYPE (info) == '-')
++    {
++      /* A stab.  */
++      printf (" ");
++      printf (other_format, SYM_STAB_OTHER (info));
++      printf (" ");
++      printf (desc_format, SYM_STAB_DESC (info));
++      printf (" %5s", SYM_STAB_NAME (info));
++    }
++  print_symname (" %s", info, NULL, abfd);
++}
++
++static void
++print_symbol_info_sysv (struct extended_symbol_info *info, bfd *abfd)
++{
++  print_symname ("%-20s|", info, NULL, abfd);
++
++  if (bfd_is_undefined_symclass (SYM_TYPE (info)))
++    {
++      if (print_width == 32)
++	printf ("        ");
++      else
++	printf ("                ");
++    }
++  else
++    print_value (abfd, SYM_VALUE (info));
++
++  printf ("|   %c  |", SYM_TYPE (info));
++
++  if (SYM_TYPE (info) == '-')
++    {
++      /* A stab.  */
++      printf ("%18s|  ", SYM_STAB_NAME (info));		/* (C) Type.  */
++      printf (desc_format, SYM_STAB_DESC (info));	/* Size.  */
++      printf ("|     |");				/* Line, Section.  */
++    }
++  else
++    {
++      /* Type, Size, Line, Section */
++      if (info->elfinfo)
++	printf ("%18s|",
++		get_elf_symbol_type (ELF_ST_TYPE (info->elfinfo->internal_elf_sym.st_info)));
++      else if (info->coffinfo)
++	printf ("%18s|",
++		get_coff_symbol_type (&info->coffinfo->native->u.syment));
++      else
++	printf ("                  |");
++
++      if (SYM_SIZE (info))
++	print_value (abfd, SYM_SIZE (info));
++      else
++	{
++	  if (print_width == 32)
++	    printf ("        ");
++	  else
++	    printf ("                ");
++	}
++
++      if (info->elfinfo)
++	printf("|     |%s", info->elfinfo->symbol.section->name);
++      else if (info->coffinfo)
++	printf("|     |%s", info->coffinfo->symbol.section->name);
++      else
++	printf("|     |");
++    }
++}
++
++static void
++print_symbol_info_posix (struct extended_symbol_info *info, bfd *abfd)
++{
++  print_symname ("%s ", info, NULL, abfd);
++  printf ("%c ", SYM_TYPE (info));
++
++  if (bfd_is_undefined_symclass (SYM_TYPE (info)))
++    printf ("        ");
++  else
++    {
++      print_value (abfd, SYM_VALUE (info));
++      printf (" ");
++      if (SYM_SIZE (info))
++	print_value (abfd, SYM_SIZE (info));
++    }
++}
++
++static void
++just_print_symbol_name (struct extended_symbol_info *info, bfd *abfd)
++{
++  print_symname ("%s", info, NULL, abfd);
++}
++
++int
++main (int argc, char **argv)
++{
++  int c;
++  int retval;
++
++#ifdef HAVE_LC_MESSAGES
++  setlocale (LC_MESSAGES, "");
++#endif
++  setlocale (LC_CTYPE, "");
++  setlocale (LC_COLLATE, "");
++  bindtextdomain (PACKAGE, LOCALEDIR);
++  textdomain (PACKAGE);
++
++  program_name = *argv;
++  xmalloc_set_program_name (program_name);
++  bfd_set_error_program_name (program_name);
++#if BFD_SUPPORTS_PLUGINS
++  bfd_plugin_set_program_name (program_name);
++#endif
++
++  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, "aABCDef:gHhjJlnopPrSst:uvVvX:",
++			   long_options, (int *) 0)) != EOF)
++    {
++      switch (c)
++	{
++	case 'a':
++	  print_debug_syms = 1;
++	  break;
++	case 'A':
++	case 'o':
++	  filename_per_symbol = 1;
++	  break;
++	case 'B':		/* For MIPS compatibility.  */
++	  set_output_format ("bsd");
++	  break;
++	case 'C':
++	  do_demangle = 1;
++	  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 OPTION_QUIET:
++	  quiet = 1;
++	  break;
++	case 'D':
++	  dynamic = 1;
++	  break;
++	case 'e':
++	  /* Ignored for HP/UX compatibility.  */
++	  break;
++	case 'f':
++	  set_output_format (optarg);
++	  break;
++	case 'g':
++	  external_only = 1;
++	  break;
++	case 'H':
++	case 'h':
++	  usage (stdout, 0);
++	case 'l':
++	  line_numbers = 1;
++	  break;
++	case 'n':
++	case 'v':
++	  no_sort = 0;
++	  sort_numerically = 1;
++	  sort_by_size = 0;
++	  break;
++	case 'p':
++	  no_sort = 1;
++	  sort_numerically = 0;
++	  sort_by_size = 0;
++	  break;
++	case OPTION_SIZE_SORT:
++	  no_sort = 0;
++	  sort_numerically = 0;
++	  sort_by_size = 1;
++	  break;
++	case 'P':
++	  set_output_format ("posix");
++	  break;
++	case 'j':
++	  set_output_format ("just-symbols");
++	  break;
++	case 'r':
++	  reverse_sort = 1;
++	  break;
++	case 's':
++	  print_armap = 1;
++	  break;
++	case 'S':
++	  print_size = 1;
++	  break;
++	case 't':
++	  set_print_radix (optarg);
++	  break;
++	case 'u':
++	  undefined_only = 1;
++	  break;
++	case 'V':
++	  show_version = 1;
++	  break;
++	case 'X':
++	  /* Ignored for (partial) AIX compatibility.  On AIX, the
++	     argument has values 32, 64, or 32_64, and specifies that
++	     only 32-bit, only 64-bit, or both kinds of objects should
++	     be examined.  The default is 32.  So plain AIX nm on a
++	     library archive with both kinds of objects will ignore
++	     the 64-bit ones.  For GNU nm, the default is and always
++	     has been -X 32_64, and other options are not supported.  */
++	  if (strcmp (optarg, "32_64") != 0)
++	    fatal (_("Only -X 32_64 is supported"));
++	  break;
++
++	case OPTION_TARGET:	/* --target */
++	  target = optarg;
++	  break;
++
++	case OPTION_PLUGIN:	/* --plugin */
++#if BFD_SUPPORTS_PLUGINS
++	  bfd_plugin_set_plugin (optarg);
++#else
++	  fatal (_("sorry - this program has been built without plugin support\n"));
++#endif
++	  break;
++
++	case OPTION_IFUNC_CHARS:
++	  ifunc_type_chars = optarg;
++	  break;
++
++	case 0:		/* A long option that just sets a flag.  */
++	  break;
++
++	default:
++	  usage (stderr, 1);
++	}
++    }
++
++  if (show_version)
++    print_version ("nm");
++
++  if (sort_by_size && undefined_only)
++    {
++      non_fatal (_("Using the --size-sort and --undefined-only options together"));
++      non_fatal (_("will produce no output, since undefined symbols have no size."));
++      return 0;
++    }
++
++  /* OK, all options now parsed.  If no filename specified, do a.out.  */
++  if (optind == argc)
++    return !display_file ("a.out");
++
++  retval = 0;
++
++  if (argc - optind > 1)
++    filename_per_file = 1;
++
++  /* We were given several filenames to do.  */
++  while (optind < argc)
++    {
++      PROGRESS (1);
++      if (!display_file (argv[optind++]))
++	retval++;
++    }
++
++  END_PROGRESS (program_name);
++
++  exit (retval);
++  return retval;
++}
+diff -rupN binutils.orig/binutils/objdump.c binutils-2.37/binutils/objdump.c
+--- binutils.orig/binutils/objdump.c	2021-11-09 12:34:21.662802941 +0000
++++ binutils-2.37/binutils/objdump.c	2021-11-09 12:40:53.084208435 +0000
+@@ -204,6 +204,18 @@ static const struct objdump_private_desc
+ 
+ /* 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;
+ 
+ static void usage (FILE *, int) ATTRIBUTE_NORETURN;
+ static void
+@@ -330,6 +342,9 @@ usage (FILE *stream, int status)
+       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"));
+@@ -420,17 +435,23 @@ static struct option long_options[]=
+ {
+   {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
+   {"all-headers", no_argument, NULL, 'x'},
+-  {"private-headers", no_argument, NULL, 'p'},
+-  {"private", required_argument, NULL, 'P'},
+   {"architecture", required_argument, NULL, 'm'},
+   {"archive-headers", no_argument, NULL, 'a'},
++#ifdef ENABLE_LIBCTF
++  {"ctf", required_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'},
+-  {"disassembler-options", required_argument, NULL, 'M'},
+   {"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},
+@@ -440,16 +461,23 @@ static struct option long_options[]=
+   {"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-show-raw-insn", no_argument, &show_raw_insn, -1},
+   {"no-addresses", no_argument, &no_addresses, 1},
+-  {"process-links", no_argument, &process_links, true},
++  {"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},
+-  {"no-recurse-limit", no_argument, NULL, OPTION_NO_RECURSE_LIMIT},
+-  {"no-recursion-limit", no_argument, NULL, OPTION_NO_RECURSE_LIMIT},
+   {"reloc", no_argument, NULL, 'r'},
+   {"section", required_argument, NULL, 'j'},
+   {"section-headers", no_argument, NULL, 'h'},
+@@ -457,28 +485,16 @@ static struct option long_options[]=
+   {"source", no_argument, NULL, 'S'},
+   {"source-comment", optional_argument, NULL, OPTION_SOURCE_COMMENT},
+   {"special-syms", no_argument, &dump_special_syms, 1},
+-  {"include", required_argument, NULL, 'I'},
+-  {"dwarf", optional_argument, NULL, OPTION_DWARF},
+-#ifdef ENABLE_LIBCTF
+-  {"ctf", required_argument, NULL, OPTION_CTF},
+-  {"ctf-parent", required_argument, NULL, OPTION_CTF_PARENT},
+-#endif
+   {"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'},
+-  {"wide", no_argument, NULL, 'w'},
+-  {"prefix", required_argument, NULL, OPTION_PREFIX},
+-  {"prefix-strip", required_argument, NULL, OPTION_PREFIX_STRIP},
+-  {"insn-width", required_argument, NULL, OPTION_INSN_WIDTH},
+-  {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
+-  {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
+-  {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
+-  {"inlines", no_argument, 0, OPTION_INLINES},
+   {"visualize-jumps", optional_argument, 0, OPTION_VISUALIZE_JUMPS},
+-  {0, no_argument, 0, 0}
++  {"wide", no_argument, NULL, 'w'},
++  {NULL, no_argument, NULL, 0}
+ };
+ 
+ static void
+@@ -488,9 +504,121 @@ nonfatal (const char *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 necessary.
++
++   If unicode display is enabled, then also handles the
++   conversion of unicode characters.  */
+ 
+ static const char *
+ sanitize_string (const char * in)
+@@ -508,40 +636,50 @@ sanitize_string (const char * in)
+      of cases it will not be needed.  */
+   do
+     {
+-      char c = *in++;
++      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) * 2))
++  if (buffer_len < (strlen (in) * 9))
+     {
+       free ((void *) buffer);
+-      buffer_len = strlen (in) * 2;
++      buffer_len = strlen (in) * 9;
+       buffer = xmalloc (buffer_len + 1);
+     }
+ 
+   out = buffer;
+   do
+     {
+-      char c = *in++;
++      unsigned char c = *in++;
+ 
+       if (c == 0)
+ 	break;
+ 
+-      if (!ISCNTRL (c))
+-	*out++ = c;
+-      else
++      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);
+ 
+@@ -4529,6 +4667,24 @@ dump_symbols (bfd *abfd ATTRIBUTE_UNUSED
+ 		  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);
+@@ -5212,7 +5368,7 @@ main (int argc, char **argv)
+   set_default_bfd_target ();
+ 
+   while ((c = getopt_long (argc, argv,
+-			   "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
++			   "pP:ib:m:M:VvCdDlfFaHhrRtTU:xsSI:j:wE:zgeGW::",
+ 			   long_options, (int *) 0))
+ 	 != EOF)
+     {
+@@ -5495,6 +5651,23 @@ main (int argc, char **argv)
+ 	  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.  */
+diff -rupN binutils.orig/binutils/objdump.c.orig binutils-2.37/binutils/objdump.c.orig
+--- binutils.orig/binutils/objdump.c.orig	1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.37/binutils/objdump.c.orig	2021-07-08 12:37:19.000000000 +0100
+@@ -0,0 +1,5534 @@
++/* objdump.c -- dump information about an object file.
++   Copyright (C) 1990-2021 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 "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 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;
++
++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
++  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\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\
++                                  The STYLE, if specified, can be `auto', `gnu',\n\
++                                  `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
++                                  or `gnat'\n"));
++      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, _("\
++  -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=SECTION       Use SECTION 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'},
++  {"private-headers", no_argument, NULL, 'p'},
++  {"private", required_argument, NULL, 'P'},
++  {"architecture", required_argument, NULL, 'm'},
++  {"archive-headers", no_argument, NULL, 'a'},
++  {"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'},
++  {"disassembler-options", required_argument, NULL, 'M'},
++  {"disassemble-zeroes", no_argument, NULL, 'z'},
++  {"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'},
++  {"info", no_argument, NULL, 'i'},
++  {"line-numbers", no_argument, NULL, 'l'},
++  {"no-show-raw-insn", no_argument, &show_raw_insn, -1},
++  {"no-addresses", no_argument, &no_addresses, 1},
++  {"process-links", no_argument, &process_links, true},
++  {"prefix-addresses", no_argument, &prefix_addresses, 1},
++  {"recurse-limit", no_argument, NULL, OPTION_RECURSE_LIMIT},
++  {"recursion-limit", no_argument, NULL, OPTION_RECURSE_LIMIT},
++  {"no-recurse-limit", no_argument, NULL, OPTION_NO_RECURSE_LIMIT},
++  {"no-recursion-limit", no_argument, NULL, OPTION_NO_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},
++  {"include", required_argument, NULL, 'I'},
++  {"dwarf", optional_argument, NULL, OPTION_DWARF},
++#ifdef ENABLE_LIBCTF
++  {"ctf", required_argument, NULL, OPTION_CTF},
++  {"ctf-parent", required_argument, NULL, OPTION_CTF_PARENT},
++#endif
++  {"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'},
++  {"version", no_argument, NULL, 'V'},
++  {"wide", no_argument, NULL, 'w'},
++  {"prefix", required_argument, NULL, OPTION_PREFIX},
++  {"prefix-strip", required_argument, NULL, OPTION_PREFIX_STRIP},
++  {"insn-width", required_argument, NULL, OPTION_INSN_WIDTH},
++  {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
++  {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
++  {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
++  {"inlines", no_argument, 0, OPTION_INLINES},
++  {"visualize-jumps", optional_argument, 0, OPTION_VISUALIZE_JUMPS},
++  {0, no_argument, 0, 0}
++};
++
++static void
++nonfatal (const char *msg)
++{
++  bfd_nonfatal (msg);
++  exit_status = 1;
++}
++
++/* Returns a version of IN with any control characters
++   replaced by escape sequences.  Uses a static buffer
++   if necessary.  */
++
++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
++    {
++      char c = *in++;
++
++      if (c == 0)
++	return original;
++
++      if (ISCNTRL (c))
++	break;
++    }
++  while (1);
++
++  /* Copy the input, translating as needed.  */
++  in = original;
++  if (buffer_len < (strlen (in) * 2))
++    {
++      free ((void *) buffer);
++      buffer_len = strlen (in) * 2;
++      buffer = xmalloc (buffer_len + 1);
++    }
++
++  out = buffer;
++  do
++    {
++      char c = *in++;
++
++      if (c == 0)
++	break;
++
++      if (!ISCNTRL (c))
++	*out++ = c;
++      else
++	{
++	  *out++ = '^';
++	  *out++ = c + 0x40;
++	}
++    }
++  while (1);
++
++  *out = 0;
++  return buffer;
++}
++
++
++/* 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);
++    }
++}
++
++
++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);
++}
++
++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 = 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);
++}
++
++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;
++
++  /* 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.  */
++  sec = bfd_get_section_by_name (abfd, section->uncompressed_name);
++  if (sec != NULL)
++    section->name = section->uncompressed_name;
++  else
++    {
++      sec = bfd_get_section_by_name (abfd, section->compressed_name);
++      if (sec != NULL)
++        section->name = section->compressed_name;
++    }
++  if (sec == NULL)
++    return false;
++
++  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 ATTRIBUTE_UNUSED)
++{
++  const char *name = bfd_section_name (section);
++  const char *match;
++  int i;
++
++  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)
++	&& 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
++	  sec->name = sec->compressed_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)
++{
++  /* 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, NULL);
++}
++
++/* 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$");
++}
++
++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");
++}
++
++
++#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 int
++dump_ctf_archive_member (ctf_dict_t *ctf, const char *name, void *arg)
++{
++  ctf_dict_t *parent = (ctf_dict_t *) arg;
++  const char *things[] = {"Header", "Labels", "Data objects",
++			  "Function objects", "Variables", "Types", "Strings",
++			  ""};
++  const char **thing;
++  size_t i;
++
++  /* Only print out the name of non-default-named archive members.
++     The name .ctf appears everywhere, even for things that aren't
++     really archives, so printing it out is liable to be confusing.
++
++     The parent, if there is one, is the default-owned archive member:
++     avoid importing it into itself.  (This does no harm, but looks
++     confusing.)  */
++
++  if (strcmp (name, ".ctf") != 0)
++    {
++      printf (_("\nCTF archive member: %s:\n"), sanitize_string (name));
++      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);
++
++  return 0;
++}
++
++/* Dump the CTF debugging information.  */
++
++static void
++dump_ctf (bfd *abfd, const char *sect_name, const char *parent_name)
++{
++  ctf_archive_t *ctfa, *parenta = NULL, *lookparent;
++  bfd_byte *ctfdata, *parentdata = NULL;
++  bfd_size_type ctfsize, parentsize;
++  ctf_sect_t ctfsect;
++  ctf_dict_t *parent = NULL;
++  int err;
++
++  if ((ctfdata = read_section_stabs (abfd, sect_name, &ctfsize, NULL)) == NULL)
++      bfd_fatal (bfd_get_filename (abfd));
++
++  if (parent_name
++      && (parentdata = read_section_stabs (abfd, parent_name, &parentsize,
++					   NULL)) == NULL)
++      bfd_fatal (bfd_get_filename (abfd));
++
++  /* Load the CTF file and dump it.  */
++
++  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 (parentdata)
++    {
++      ctfsect = make_ctfsect (parent_name, parentdata, parentsize);
++      if ((parenta = 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));
++	}
++
++      lookparent = parenta;
++    }
++  else
++    lookparent = ctfa;
++
++  /* Assume that the applicable parent archive member is the default one.
++     (This is what all known implementations are expected to do, if they
++     put CTFs and their parents in archives together.)  */
++  if ((parent = ctf_dict_open (lookparent, NULL, &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));
++
++  if ((err = ctf_archive_iter (ctfa, dump_ctf_archive_member, parent)) != 0)
++    {
++      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);
++  ctf_close (parenta);
++  free (parentdata);
++  free (ctfdata);
++}
++#else
++static void
++dump_ctf (bfd *abfd ATTRIBUTE_UNUSED, const char *sect_name ATTRIBUTE_UNUSED,
++	  const char *parent_name ATTRIBUTE_UNUSED) {}
++#endif
++
++
++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);
++}
++
++/* 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
++	    bfd_print_symbol (cur_bfd, stdout, *current,
++			      bfd_print_symbol_all);
++	  printf ("\n");
++	}
++
++      current++;
++    }
++  printf ("\n\n");
++}
++
++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 (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)
++    return;
++
++  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 (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);
++  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);
++	}
++    }
++
++  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);
++}
++
++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,
++			   "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
++			   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;
++	  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 '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);
++
++  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;
++}
+diff -rupN binutils.orig/binutils/objdump.c.rej binutils-2.37/binutils/objdump.c.rej
+--- binutils.orig/binutils/objdump.c.rej	1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.37/binutils/objdump.c.rej	2021-11-09 12:34:46.291643864 +0000
+@@ -0,0 +1,43 @@
++--- binutils/objdump.c
+++++ binutils/objdump.c
++@@ -487,28 +517,16 @@ static struct option long_options[]=
++   {"source", no_argument, NULL, 'S'},
++   {"source-comment", optional_argument, NULL, OPTION_SOURCE_COMMENT},
++   {"special-syms", no_argument, &dump_special_syms, 1},
++-  {"include", required_argument, NULL, 'I'},
++-  {"dwarf", optional_argument, NULL, OPTION_DWARF},
++-#ifdef ENABLE_LIBCTF
++-  {"ctf", optional_argument, NULL, OPTION_CTF},
++-  {"ctf-parent", required_argument, NULL, OPTION_CTF_PARENT},
++-#endif
++   {"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'},
++-  {"wide", no_argument, NULL, 'w'},
++-  {"prefix", required_argument, NULL, OPTION_PREFIX},
++-  {"prefix-strip", required_argument, NULL, OPTION_PREFIX_STRIP},
++-  {"insn-width", required_argument, NULL, OPTION_INSN_WIDTH},
++-  {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
++-  {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
++-  {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
++-  {"inlines", no_argument, 0, OPTION_INLINES},
++   {"visualize-jumps", optional_argument, 0, OPTION_VISUALIZE_JUMPS},
++-  {0, no_argument, 0, 0}
+++  {"wide", no_argument, NULL, 'w'},
+++  {NULL, no_argument, NULL, 0}
++ };
++ 
++ static void
++@@ -5375,7 +5533,7 @@ main (int argc, char **argv)
++   set_default_bfd_target ();
++ 
++   while ((c = getopt_long (argc, argv,
++-			   "CDE:FGHI:LM:P:RSTVW::ab:defghij:lm:prstvwxz",
+++			   "CDE:FGHI:LM:P:RSTU:VW::ab:defghij:lm:prstvwxz",
++ 			   long_options, (int *) 0))
++ 	 != EOF)
++     {
+diff -rupN binutils.orig/binutils/readelf.c binutils-2.37/binutils/readelf.c
+--- binutils.orig/binutils/readelf.c	2021-11-09 12:34:21.680802825 +0000
++++ binutils-2.37/binutils/readelf.c	2021-11-09 12:34:46.293643851 +0000
+@@ -328,6 +328,19 @@ typedef enum print_mode
+ }
+ print_mode;
+ 
++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;
++
++  
+ /* Versioned symbol info.  */
+ enum versioned_symbol_info
+ {
+@@ -632,11 +645,18 @@ print_symbol (signed int width, const ch
+       if (c == 0)
+ 	break;
+ 
+-      /* Do not print control characters directly as they can affect terminal
+-	 settings.  Such characters usually appear in the names generated
+-	 by the assembler for local labels.  */
+-      if (ISCNTRL (c))
++      if (ISPRINT (c))
++	{
++	  putchar (c);
++	  width_remaining --;
++	  num_printed ++;
++	}
++      else if (ISCNTRL (c))
+ 	{
++	  /* Do not print control characters directly as they can affect terminal
++	     settings.  Such characters usually appear in the names generated
++	     by the assembler for local labels.  */
++
+ 	  if (width_remaining < 2)
+ 	    break;
+ 
+@@ -644,11 +664,137 @@ print_symbol (signed int width, const ch
+ 	  width_remaining -= 2;
+ 	  num_printed += 2;
+ 	}
+-      else if (ISPRINT (c))
++      else if (c == 0x7f)
+ 	{
+-	  putchar (c);
+-	  width_remaining --;
+-	  num_printed ++;
++	  if (width_remaining < 5)
++	    break;
++	  printf ("<DEL>");
++	  width_remaining -= 5;
++	  num_printed += 5;
++	}
++      else if (unicode_display != unicode_locale
++	       && unicode_display != unicode_default)
++	{
++	  /* Display unicode characters as something else.  */
++	  unsigned char bytes[4];
++	  bool          is_utf8;
++	  uint          nbytes;
++
++	  bytes[0] = c;
++
++	  if (bytes[0] < 0xc0)
++	    {
++	      nbytes = 1;
++	      is_utf8 = false;
++	    }
++	  else
++	    {
++	      bytes[1] = *symbol++;
++
++	      if ((bytes[1] & 0xc0) != 0x80)
++		{
++		  is_utf8 = false;
++		  /* Do not consume this character.  It may only
++		     be the first byte in the sequence that was
++		     corrupt.  */
++		  --symbol;
++		  nbytes = 1;
++		}
++	      else if ((bytes[0] & 0x20) == 0)
++		{
++		  is_utf8 = true;
++		  nbytes = 2;
++		}
++	      else
++		{
++		  bytes[2] = *symbol++;
++
++		  if ((bytes[2] & 0xc0) != 0x80)
++		    {
++		      is_utf8 = false;
++		      symbol -= 2;
++		      nbytes = 1;
++		    }
++		  else if ((bytes[0] & 0x10) == 0)
++		    {
++		      is_utf8 = true;
++		      nbytes = 3;
++		    }
++		  else
++		    {
++		      bytes[3] = *symbol++;
++
++		      nbytes = 4;
++
++		      if ((bytes[3] & 0xc0) != 0x80)
++			{
++			  is_utf8 = false;
++			  symbol -= 3;
++			  nbytes = 1;
++			}
++		      else
++			is_utf8 = true;
++		    }
++		}
++	    }
++
++	  if (unicode_display == unicode_invalid)
++	    is_utf8 = false;
++
++	  if (unicode_display == unicode_hex || ! is_utf8)
++	    {
++	      uint i;
++
++	      if (width_remaining < (nbytes * 2) + 2)
++		break;
++	  
++	      putchar (is_utf8 ? '<' : '{');
++	      printf ("0x");
++	      for (i = 0; i < nbytes; i++)
++		printf ("%02x", bytes[i]);
++	      putchar (is_utf8 ? '>' : '}');
++	    }
++	  else
++	    {
++	      if (unicode_display == unicode_highlight && isatty (1))
++		printf ("\x1B[31;47m"); /* Red.  */
++	      
++	      switch (nbytes)
++		{
++		case 2:
++		  if (width_remaining < 6)
++		    break;
++		  printf ("\\u%02x%02x",
++			  (bytes[0] & 0x1c) >> 2, 
++			  ((bytes[0] & 0x03) << 6) | (bytes[1] & 0x3f));
++		  break;
++		case 3:
++		  if (width_remaining < 6)
++		    break;
++		  printf ("\\u%02x%02x",
++			  ((bytes[0] & 0x0f) << 4) | ((bytes[1] & 0x3c) >> 2),
++			  ((bytes[1] & 0x03) << 6) | (bytes[2] & 0x3f));
++		  break;
++		case 4:
++		  if (width_remaining < 8)
++		    break;
++		  printf ("\\u%02x%02x%02x",
++			  ((bytes[0] & 0x07) << 6) | ((bytes[1] & 0x3c) >> 2),
++			  ((bytes[1] & 0x03) << 6) | ((bytes[2] & 0x3c) >> 2),
++			  ((bytes[2] & 0x03) << 6) | (bytes[3] & 0x3f));
++		  
++		  break;
++		default:
++		  /* URG.  */
++		  break;
++		}
++
++	      if (unicode_display == unicode_highlight && isatty (1))
++		printf ("\033[0m"); /* Default colour.  */
++	    }
++	  
++	  if (bytes[nbytes - 1] == 0)
++	    break;
+ 	}
+       else
+ 	{
+@@ -4668,6 +4814,7 @@ static struct option options[] =
+   {"syms",	       no_argument, 0, 's'},
+   {"silent-truncation",no_argument, 0, 'T'},
+   {"section-details",  no_argument, 0, 't'},
++  {"unicode",          required_argument, NULL, 'U'},
+   {"unwind",	       no_argument, 0, 'u'},
+   {"version-info",     no_argument, 0, 'V'},
+   {"version",	       no_argument, 0, 'v'},
+@@ -4744,6 +4891,12 @@ usage (FILE * stream)
+   fprintf (stream, _("\
+      --no-recurse-limit  Disable a demangling recursion limit\n"));
+   fprintf (stream, _("\
++     -U[dlexhi] --unicode=[default|locale|escape|hex|highlight|invalid]\n\
++                         Display unicode characters as determined by the current locale\n\
++                          (default), escape sequences, \"<hex sequences>\", highlighted\n\
++                          escape sequences, or treat them as invalid and display as\n\
++                          \"{hex sequences}\"\n"));
++  fprintf (stream, _("\
+   -n --notes             Display the core notes (if present)\n"));
+   fprintf (stream, _("\
+   -r --relocs            Display the relocations (if present)\n"));
+@@ -4928,7 +5081,7 @@ parse_args (struct dump_data *dumpdata,
+     usage (stderr);
+ 
+   while ((c = getopt_long
+-	  (argc, argv, "ACDHILNPR:STVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
++	  (argc, argv, "ACDHILNPR:STU:VWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
+     {
+       switch (c)
+ 	{
+@@ -5130,6 +5283,25 @@ parse_args (struct dump_data *dumpdata,
+ 	  /* Ignored for backward compatibility.  */
+ 	  break;
+ 
++	case 'U':
++	  if (optarg == NULL)
++	    error (_("Missing arg to -U/--unicode")); /* Can this happen ?  */
++	  else 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
++	    error (_("invalid argument to -U/--unicode: %s"), optarg);
++	  break;
++
+ 	case OPTION_SYM_BASE:
+ 	  sym_base = 0;
+ 	  if (optarg != NULL)
+diff -rupN binutils.orig/binutils/readelf.c.orig binutils-2.37/binutils/readelf.c.orig
+--- binutils.orig/binutils/readelf.c.orig	1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.37/binutils/readelf.c.orig	2021-11-09 12:34:05.099909925 +0000
+@@ -0,0 +1,22045 @@
++/* readelf.c -- display contents of an ELF format file
++   Copyright (C) 1998-2021 Free Software Foundation, Inc.
++
++   Originally developed by Eric Youngdale <eric@andante.jic.com>
++   Modifications by Nick Clifton <nickc@redhat.com>
++
++   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 of the License, 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, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
++   02110-1301, USA.  */
++
++/* The difference between readelf and objdump:
++
++  Both programs are capable of displaying the contents of ELF format files,
++  so why does the binutils project have two file dumpers ?
++
++  The reason is that objdump sees an ELF file through a BFD filter of the
++  world; if BFD has a bug where, say, it disagrees about a machine constant
++  in e_flags, then the odds are good that it will remain internally
++  consistent.  The linker sees it the BFD way, objdump sees it the BFD way,
++  GAS sees it the BFD way.  There was need for a tool to go find out what
++  the file actually says.
++
++  This is why the readelf program does not link against the BFD library - it
++  exists as an independent program to help verify the correct working of BFD.
++
++  There is also the case that readelf can provide more information about an
++  ELF file than is provided by objdump.  In particular it can display DWARF
++  debugging information which (at the moment) objdump cannot.  */
++
++#include "sysdep.h"
++#include <assert.h>
++#include <time.h>
++#include <zlib.h>
++#include <wchar.h>
++
++#if __GNUC__ >= 2
++/* Define BFD64 here, even if our default architecture is 32 bit ELF
++   as this will allow us to read in and parse 64bit and 32bit ELF files.
++   Only do this if we believe that the compiler can support a 64 bit
++   data type.  For now we only rely on GCC being able to do this.  */
++#define BFD64
++#endif
++
++#include "bfd.h"
++#include "bucomm.h"
++#include "elfcomm.h"
++#include "dwarf.h"
++#include "ctf-api.h"
++#include "demangle.h"
++
++#include "elf/common.h"
++#include "elf/external.h"
++#include "elf/internal.h"
++
++
++/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
++   we can obtain the H8 reloc numbers.  We need these for the
++   get_reloc_size() function.  We include h8.h again after defining
++   RELOC_MACROS_GEN_FUNC so that we get the naming function as well.  */
++
++#include "elf/h8.h"
++#undef _ELF_H8_H
++
++/* Undo the effects of #including reloc-macros.h.  */
++
++#undef START_RELOC_NUMBERS
++#undef RELOC_NUMBER
++#undef FAKE_RELOC
++#undef EMPTY_RELOC
++#undef END_RELOC_NUMBERS
++#undef _RELOC_MACROS_H
++
++/* The following headers use the elf/reloc-macros.h file to
++   automatically generate relocation recognition functions
++   such as elf_mips_reloc_type()  */
++
++#define RELOC_MACROS_GEN_FUNC
++
++#include "elf/aarch64.h"
++#include "elf/alpha.h"
++#include "elf/arc.h"
++#include "elf/arm.h"
++#include "elf/avr.h"
++#include "elf/bfin.h"
++#include "elf/cr16.h"
++#include "elf/cris.h"
++#include "elf/crx.h"
++#include "elf/csky.h"
++#include "elf/d10v.h"
++#include "elf/d30v.h"
++#include "elf/dlx.h"
++#include "elf/bpf.h"
++#include "elf/epiphany.h"
++#include "elf/fr30.h"
++#include "elf/frv.h"
++#include "elf/ft32.h"
++#include "elf/h8.h"
++#include "elf/hppa.h"
++#include "elf/i386.h"
++#include "elf/i370.h"
++#include "elf/i860.h"
++#include "elf/i960.h"
++#include "elf/ia64.h"
++#include "elf/ip2k.h"
++#include "elf/lm32.h"
++#include "elf/iq2000.h"
++#include "elf/m32c.h"
++#include "elf/m32r.h"
++#include "elf/m68k.h"
++#include "elf/m68hc11.h"
++#include "elf/s12z.h"
++#include "elf/mcore.h"
++#include "elf/mep.h"
++#include "elf/metag.h"
++#include "elf/microblaze.h"
++#include "elf/mips.h"
++#include "elf/mmix.h"
++#include "elf/mn10200.h"
++#include "elf/mn10300.h"
++#include "elf/moxie.h"
++#include "elf/mt.h"
++#include "elf/msp430.h"
++#include "elf/nds32.h"
++#include "elf/nfp.h"
++#include "elf/nios2.h"
++#include "elf/or1k.h"
++#include "elf/pj.h"
++#include "elf/ppc.h"
++#include "elf/ppc64.h"
++#include "elf/pru.h"
++#include "elf/riscv.h"
++#include "elf/rl78.h"
++#include "elf/rx.h"
++#include "elf/s390.h"
++#include "elf/score.h"
++#include "elf/sh.h"
++#include "elf/sparc.h"
++#include "elf/spu.h"
++#include "elf/tic6x.h"
++#include "elf/tilegx.h"
++#include "elf/tilepro.h"
++#include "elf/v850.h"
++#include "elf/vax.h"
++#include "elf/visium.h"
++#include "elf/wasm32.h"
++#include "elf/x86-64.h"
++#include "elf/xc16x.h"
++#include "elf/xgate.h"
++#include "elf/xstormy16.h"
++#include "elf/xtensa.h"
++#include "elf/z80.h"
++
++#include "getopt.h"
++#include "libiberty.h"
++#include "safe-ctype.h"
++#include "filenames.h"
++
++#ifndef offsetof
++#define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
++#endif
++
++typedef struct elf_section_list
++{
++  Elf_Internal_Shdr *        hdr;
++  struct elf_section_list *  next;
++} elf_section_list;
++
++/* Flag bits indicating particular types of dump.  */
++#define HEX_DUMP	(1 << 0)	/* The -x command line switch.  */
++#define DISASS_DUMP	(1 << 1)	/* The -i command line switch.  */
++#define DEBUG_DUMP	(1 << 2)	/* The -w command line switch.  */
++#define STRING_DUMP     (1 << 3)	/* The -p command line switch.  */
++#define RELOC_DUMP      (1 << 4)	/* The -R command line switch.  */
++#define CTF_DUMP	(1 << 5)	/* The --ctf command line switch.  */
++
++typedef unsigned char dump_type;
++
++/* A linked list of the section names for which dumps were requested.  */
++struct dump_list_entry
++{
++  char *                    name;
++  dump_type                 type;
++  struct dump_list_entry *  next;
++};
++
++/* A dynamic array of flags indicating for which sections a dump
++   has been requested via command line switches.  */
++struct dump_data
++{
++  dump_type *          dump_sects;
++  unsigned int         num_dump_sects;
++};
++
++static struct dump_data cmdline;
++
++static struct dump_list_entry * dump_sects_byname;
++
++char * program_name = "readelf";
++
++static bool show_name = false;
++static bool do_dynamic = false;
++static bool do_syms = false;
++static bool do_dyn_syms = false;
++static bool do_lto_syms = false;
++static bool do_reloc = false;
++static bool do_sections = false;
++static bool do_section_groups = false;
++static bool do_section_details = false;
++static bool do_segments = false;
++static bool do_unwind = false;
++static bool do_using_dynamic = false;
++static bool do_header = false;
++static bool do_dump = false;
++static bool do_version = false;
++static bool do_histogram = false;
++static bool do_debugging = false;
++static bool do_ctf = false;
++static bool do_arch = false;
++static bool do_notes = false;
++static bool do_archive_index = false;
++static bool check_all = false;
++static bool is_32bit_elf = false;
++static bool decompress_dumps = false;
++static bool do_not_show_symbol_truncation = false;
++static bool do_demangle = false;	/* Pretty print C++ symbol names.  */
++static bool process_links = false;
++static int demangle_flags = DMGL_ANSI | DMGL_PARAMS;
++static int sym_base = 0;
++
++static char *dump_ctf_parent_name;
++static char *dump_ctf_symtab_name;
++static char *dump_ctf_strtab_name;
++
++struct group_list
++{
++  struct group_list *  next;
++  unsigned int         section_index;
++};
++
++struct group
++{
++  struct group_list *  root;
++  unsigned int         group_index;
++};
++
++typedef struct filedata
++{
++  const char *         file_name;
++  bool                 is_separate;
++  FILE *               handle;
++  bfd_size_type        file_size;
++  Elf_Internal_Ehdr    file_header;
++  unsigned long        archive_file_offset;
++  unsigned long        archive_file_size;
++  /* Everything below this point is cleared out by free_filedata.  */
++  Elf_Internal_Shdr *  section_headers;
++  Elf_Internal_Phdr *  program_headers;
++  char *               string_table;
++  unsigned long        string_table_length;
++  unsigned long        dynamic_addr;
++  bfd_size_type        dynamic_size;
++  size_t               dynamic_nent;
++  Elf_Internal_Dyn *   dynamic_section;
++  Elf_Internal_Shdr *  dynamic_strtab_section;
++  char *               dynamic_strings;
++  unsigned long        dynamic_strings_length;
++  Elf_Internal_Shdr *  dynamic_symtab_section;
++  unsigned long        num_dynamic_syms;
++  Elf_Internal_Sym *   dynamic_symbols;
++  bfd_vma              version_info[16];
++  unsigned int         dynamic_syminfo_nent;
++  Elf_Internal_Syminfo * dynamic_syminfo;
++  unsigned long        dynamic_syminfo_offset;
++  bfd_size_type        nbuckets;
++  bfd_size_type        nchains;
++  bfd_vma *            buckets;
++  bfd_vma *            chains;
++  bfd_size_type        ngnubuckets;
++  bfd_size_type        ngnuchains;
++  bfd_vma *            gnubuckets;
++  bfd_vma *            gnuchains;
++  bfd_vma *            mipsxlat;
++  bfd_vma              gnusymidx;
++  char *               program_interpreter;
++  bfd_vma              dynamic_info[DT_ENCODING];
++  bfd_vma              dynamic_info_DT_GNU_HASH;
++  bfd_vma              dynamic_info_DT_MIPS_XHASH;
++  elf_section_list *   symtab_shndx_list;
++  size_t               group_count;
++  struct group *       section_groups;
++  struct group **      section_headers_groups;
++  /* A dynamic array of flags indicating for which sections a dump of
++     some kind has been requested.  It is reset on a per-object file
++     basis and then initialised from the cmdline_dump_sects array,
++     the results of interpreting the -w switch, and the
++     dump_sects_byname list.  */
++  struct dump_data     dump;
++} Filedata;
++
++/* How to print a vma value.  */
++typedef enum print_mode
++{
++  HEX,
++  HEX_5,
++  DEC,
++  DEC_5,
++  UNSIGNED,
++  UNSIGNED_5,
++  PREFIX_HEX,
++  PREFIX_HEX_5,
++  FULL_HEX,
++  LONG_HEX,
++  OCTAL,
++  OCTAL_5
++}
++print_mode;
++
++/* Versioned symbol info.  */
++enum versioned_symbol_info
++{
++  symbol_undefined,
++  symbol_hidden,
++  symbol_public
++};
++
++static const char * get_symbol_version_string
++  (Filedata *, bool, const char *, unsigned long, unsigned,
++   Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
++
++#define UNKNOWN -1
++
++#define SECTION_NAME(X) \
++  (filedata->string_table + (X)->sh_name)
++
++#define SECTION_NAME_VALID(X) \
++  ((X) != NULL								\
++   && filedata->string_table != NULL					\
++   && (X)->sh_name < filedata->string_table_length)
++
++#define SECTION_NAME_PRINT(X) \
++  ((X) == NULL ? _("<none>")						\
++   : filedata->string_table == NULL ? _("<no-strings>")			\
++   : (X)->sh_name >= filedata->string_table_length ? _("<corrupt>")	\
++   : filedata->string_table + (X)->sh_name)
++
++#define DT_VERSIONTAGIDX(tag)	(DT_VERNEEDNUM - (tag))	/* Reverse order!  */
++
++#define VALID_SYMBOL_NAME(strtab, strtab_size, offset) \
++   (strtab != NULL && offset < strtab_size)
++#define VALID_DYNAMIC_NAME(filedata, offset) \
++  VALID_SYMBOL_NAME (filedata->dynamic_strings, \
++		     filedata->dynamic_strings_length, offset)
++/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
++   already been called and verified that the string exists.  */
++#define GET_DYNAMIC_NAME(filedata, offset) \
++  (filedata->dynamic_strings + offset)
++
++#define REMOVE_ARCH_BITS(ADDR)			\
++  do						\
++    {						\
++      if (filedata->file_header.e_machine == EM_ARM)	\
++	(ADDR) &= ~1;				\
++    }						\
++  while (0)
++
++/* Get the correct GNU hash section name.  */
++#define GNU_HASH_SECTION_NAME(filedata)		\
++  filedata->dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
++
++/* Print a BFD_VMA to an internal buffer, for use in error messages.
++   BFD_FMA_FMT can't be used in translated strings.  */
++
++static const char *
++bfd_vmatoa (char *fmtch, bfd_vma value)
++{
++  /* bfd_vmatoa is used more then once in a printf call for output.
++     Cycle through an array of buffers.  */
++  static int buf_pos = 0;
++  static struct bfd_vmatoa_buf
++  {
++    char place[64];
++  } buf[4];
++  char *ret;
++  char fmt[32];
++
++  ret = buf[buf_pos++].place;
++  buf_pos %= ARRAY_SIZE (buf);
++
++  sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch);
++  snprintf (ret, sizeof (buf[0].place), fmt, value);
++  return ret;
++}
++
++/* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
++   OFFSET + the offset of the current archive member, if we are examining an
++   archive.  Put the retrieved data into VAR, if it is not NULL.  Otherwise
++   allocate a buffer using malloc and fill that.  In either case return the
++   pointer to the start of the retrieved data or NULL if something went wrong.
++   If something does go wrong and REASON is not NULL then emit an error
++   message using REASON as part of the context.  */
++
++static void *
++get_data (void *         var,
++	  Filedata *     filedata,
++	  unsigned long  offset,
++	  bfd_size_type  size,
++	  bfd_size_type  nmemb,
++	  const char *   reason)
++{
++  void * mvar;
++  bfd_size_type amt = size * nmemb;
++
++  if (size == 0 || nmemb == 0)
++    return NULL;
++
++  /* If the size_t type is smaller than the bfd_size_type, eg because
++     you are building a 32-bit tool on a 64-bit host, then make sure
++     that when the sizes are cast to (size_t) no information is lost.  */
++  if ((size_t) size != size
++      || (size_t) nmemb != nmemb
++      || (size_t) amt != amt)
++    {
++      if (reason)
++	error (_("Size truncation prevents reading %s"
++		 " elements of size %s for %s\n"),
++	       bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
++      return NULL;
++    }
++
++  /* Check for size overflow.  */
++  if (amt / size != nmemb || (size_t) amt + 1 == 0)
++    {
++      if (reason)
++	error (_("Size overflow prevents reading %s"
++		 " elements of size %s for %s\n"),
++	       bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
++      return NULL;
++    }
++
++  /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
++     attempting to allocate memory when the read is bound to fail.  */
++  if (filedata->archive_file_offset > filedata->file_size
++      || offset > filedata->file_size - filedata->archive_file_offset
++      || amt > filedata->file_size - filedata->archive_file_offset - offset)
++    {
++      if (reason)
++	error (_("Reading %s bytes extends past end of file for %s\n"),
++	       bfd_vmatoa ("u", amt), reason);
++      return NULL;
++    }
++
++  if (fseek (filedata->handle, filedata->archive_file_offset + offset,
++	     SEEK_SET))
++    {
++      if (reason)
++	error (_("Unable to seek to 0x%lx for %s\n"),
++	       filedata->archive_file_offset + offset, reason);
++      return NULL;
++    }
++
++  mvar = var;
++  if (mvar == NULL)
++    {
++      /* + 1 so that we can '\0' terminate invalid string table sections.  */
++      mvar = malloc ((size_t) amt + 1);
++
++      if (mvar == NULL)
++	{
++	  if (reason)
++	    error (_("Out of memory allocating %s bytes for %s\n"),
++		   bfd_vmatoa ("u", amt), reason);
++	  return NULL;
++	}
++
++      ((char *) mvar)[amt] = '\0';
++    }
++
++  if (fread (mvar, (size_t) size, (size_t) nmemb, filedata->handle) != nmemb)
++    {
++      if (reason)
++	error (_("Unable to read in %s bytes of %s\n"),
++	       bfd_vmatoa ("u", amt), reason);
++      if (mvar != var)
++	free (mvar);
++      return NULL;
++    }
++
++  return mvar;
++}
++
++/* Print a VMA value in the MODE specified.
++   Returns the number of characters displayed.  */
++
++static unsigned int
++print_vma (bfd_vma vma, print_mode mode)
++{
++  unsigned int nc = 0;
++
++  switch (mode)
++    {
++    case FULL_HEX:
++      nc = printf ("0x");
++      /* Fall through.  */
++    case LONG_HEX:
++#ifdef BFD64
++      if (is_32bit_elf)
++	return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
++#endif
++      printf_vma (vma);
++      return nc + 16;
++
++    case DEC_5:
++      if (vma <= 99999)
++	return printf ("%5" BFD_VMA_FMT "d", vma);
++      /* Fall through.  */
++    case PREFIX_HEX:
++      nc = printf ("0x");
++      /* Fall through.  */
++    case HEX:
++      return nc + printf ("%" BFD_VMA_FMT "x", vma);
++
++    case PREFIX_HEX_5:
++      nc = printf ("0x");
++      /* Fall through.  */
++    case HEX_5:
++      return nc + printf ("%05" BFD_VMA_FMT "x", vma);
++
++    case DEC:
++      return printf ("%" BFD_VMA_FMT "d", vma);
++
++    case UNSIGNED:
++      return printf ("%" BFD_VMA_FMT "u", vma);
++
++    case UNSIGNED_5:
++      return printf ("%5" BFD_VMA_FMT "u", vma);
++
++    case OCTAL:
++      return printf ("%" BFD_VMA_FMT "o", vma);
++
++    case OCTAL_5:
++      return printf ("%5" BFD_VMA_FMT "o", vma);
++
++    default:
++      /* FIXME: Report unrecognised mode ?  */
++      return 0;
++    }
++}
++
++
++/* Display a symbol on stdout.  Handles the display of control characters and
++   multibye characters (assuming the host environment supports them).
++
++   Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
++
++   If truncation will happen and do_not_show_symbol_truncation is FALSE then display
++   abs(WIDTH) - 5 characters followed by "[...]".
++
++   If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
++   padding as necessary.
++
++   Returns the number of emitted characters.  */
++
++static unsigned int
++print_symbol (signed int width, const char * symbol)
++{
++  bool extra_padding = false;
++  bool do_dots = false;
++  signed int num_printed = 0;
++#ifdef HAVE_MBSTATE_T
++  mbstate_t state;
++#endif
++  unsigned int width_remaining;
++  const void * alloced_symbol = NULL;
++
++  if (width < 0)
++    {
++      /* Keep the width positive.  This helps the code below.  */
++      width = - width;
++      extra_padding = true;
++    }
++  else if (width == 0)
++    return 0;
++
++  if (do_wide)
++    /* Set the remaining width to a very large value.
++       This simplifies the code below.  */
++    width_remaining = INT_MAX;
++  else
++    {
++      width_remaining = width;
++      if (! do_not_show_symbol_truncation
++	  && (int) strlen (symbol) > width)
++	{
++	  width_remaining -= 5;
++	  if ((int) width_remaining < 0)
++	    width_remaining = 0;
++	  do_dots = true;
++	}
++    }
++
++#ifdef HAVE_MBSTATE_T
++  /* Initialise the multibyte conversion state.  */
++  memset (& state, 0, sizeof (state));
++#endif
++
++  if (do_demangle && *symbol)
++    {
++      const char * res = cplus_demangle (symbol, demangle_flags);
++
++      if (res != NULL)
++	alloced_symbol = symbol = res;
++    }
++
++  while (width_remaining)
++    {
++      size_t  n;
++      const char c = *symbol++;
++
++      if (c == 0)
++	break;
++
++      /* Do not print control characters directly as they can affect terminal
++	 settings.  Such characters usually appear in the names generated
++	 by the assembler for local labels.  */
++      if (ISCNTRL (c))
++	{
++	  if (width_remaining < 2)
++	    break;
++
++	  printf ("^%c", c + 0x40);
++	  width_remaining -= 2;
++	  num_printed += 2;
++	}
++      else if (ISPRINT (c))
++	{
++	  putchar (c);
++	  width_remaining --;
++	  num_printed ++;
++	}
++      else
++	{
++#ifdef HAVE_MBSTATE_T
++	  wchar_t w;
++#endif
++	  /* Let printf do the hard work of displaying multibyte characters.  */
++	  printf ("%.1s", symbol - 1);
++	  width_remaining --;
++	  num_printed ++;
++
++#ifdef HAVE_MBSTATE_T
++	  /* Try to find out how many bytes made up the character that was
++	     just printed.  Advance the symbol pointer past the bytes that
++	     were displayed.  */
++	  n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
++#else
++	  n = 1;
++#endif
++	  if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
++	    symbol += (n - 1);
++	}
++    }
++
++  if (do_dots)
++    num_printed += printf ("[...]");
++
++  if (extra_padding && num_printed < width)
++    {
++      /* Fill in the remaining spaces.  */
++      printf ("%-*s", width - num_printed, " ");
++      num_printed = width;
++    }
++
++  free ((void *) alloced_symbol);
++  return num_printed;
++}
++
++/* Returns a pointer to a static buffer containing a printable version of
++   the given section's name.  Like print_symbol, except that it does not try
++   to print multibyte characters, it just interprets them as hex values.  */
++
++static const char *
++printable_section_name (Filedata * filedata, const Elf_Internal_Shdr * sec)
++{
++#define MAX_PRINT_SEC_NAME_LEN 256
++  static char  sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
++  const char * name = SECTION_NAME_PRINT (sec);
++  char *       buf = sec_name_buf;
++  char         c;
++  unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
++
++  while ((c = * name ++) != 0)
++    {
++      if (ISCNTRL (c))
++	{
++	  if (remaining < 2)
++	    break;
++
++	  * buf ++ = '^';
++	  * buf ++ = c + 0x40;
++	  remaining -= 2;
++	}
++      else if (ISPRINT (c))
++	{
++	  * buf ++ = c;
++	  remaining -= 1;
++	}
++      else
++	{
++	  static char hex[17] = "0123456789ABCDEF";
++
++	  if (remaining < 4)
++	    break;
++	  * buf ++ = '<';
++	  * buf ++ = hex[(c & 0xf0) >> 4];
++	  * buf ++ = hex[c & 0x0f];
++	  * buf ++ = '>';
++	  remaining -= 4;
++	}
++
++      if (remaining == 0)
++	break;
++    }
++
++  * buf = 0;
++  return sec_name_buf;
++}
++
++static const char *
++printable_section_name_from_index (Filedata * filedata, unsigned long ndx)
++{
++  if (ndx >= filedata->file_header.e_shnum)
++    return _("<corrupt>");
++
++  return printable_section_name (filedata, filedata->section_headers + ndx);
++}
++
++/* Return a pointer to section NAME, or NULL if no such section exists.  */
++
++static Elf_Internal_Shdr *
++find_section (Filedata * filedata, const char * name)
++{
++  unsigned int i;
++
++  if (filedata->section_headers == NULL)
++    return NULL;
++
++  for (i = 0; i < filedata->file_header.e_shnum; i++)
++    if (SECTION_NAME_VALID (filedata->section_headers + i)
++	&& streq (SECTION_NAME (filedata->section_headers + i), name))
++      return filedata->section_headers + i;
++
++  return NULL;
++}
++
++/* Return a pointer to a section containing ADDR, or NULL if no such
++   section exists.  */
++
++static Elf_Internal_Shdr *
++find_section_by_address (Filedata * filedata, bfd_vma addr)
++{
++  unsigned int i;
++
++  if (filedata->section_headers == NULL)
++    return NULL;
++
++  for (i = 0; i < filedata->file_header.e_shnum; i++)
++    {
++      Elf_Internal_Shdr *sec = filedata->section_headers + i;
++
++      if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
++	return sec;
++    }
++
++  return NULL;
++}
++
++static Elf_Internal_Shdr *
++find_section_by_type (Filedata * filedata, unsigned int type)
++{
++  unsigned int i;
++
++  if (filedata->section_headers == NULL)
++    return NULL;
++
++  for (i = 0; i < filedata->file_header.e_shnum; i++)
++    {
++      Elf_Internal_Shdr *sec = filedata->section_headers + i;
++
++      if (sec->sh_type == type)
++	return sec;
++    }
++
++  return NULL;
++}
++
++/* Return a pointer to section NAME, or NULL if no such section exists,
++   restricted to the list of sections given in SET.  */
++
++static Elf_Internal_Shdr *
++find_section_in_set (Filedata * filedata, const char * name, unsigned int * set)
++{
++  unsigned int i;
++
++  if (filedata->section_headers == NULL)
++    return NULL;
++
++  if (set != NULL)
++    {
++      while ((i = *set++) > 0)
++	{
++	  /* See PR 21156 for a reproducer.  */
++	  if (i >= filedata->file_header.e_shnum)
++	    continue; /* FIXME: Should we issue an error message ?  */
++
++	  if (SECTION_NAME_VALID (filedata->section_headers + i)
++	      && streq (SECTION_NAME (filedata->section_headers + i), name))
++	    return filedata->section_headers + i;
++	}
++    }
++
++  return find_section (filedata, name);
++}
++
++/* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
++   This OS has so many departures from the ELF standard that we test it at
++   many places.  */
++
++static inline bool
++is_ia64_vms (Filedata * filedata)
++{
++  return filedata->file_header.e_machine == EM_IA_64
++    && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
++}
++
++/* Guess the relocation size commonly used by the specific machines.  */
++
++static bool
++guess_is_rela (unsigned int e_machine)
++{
++  switch (e_machine)
++    {
++      /* Targets that use REL relocations.  */
++    case EM_386:
++    case EM_IAMCU:
++    case EM_960:
++    case EM_ARM:
++    case EM_D10V:
++    case EM_CYGNUS_D10V:
++    case EM_DLX:
++    case EM_MIPS:
++    case EM_MIPS_RS3_LE:
++    case EM_CYGNUS_M32R:
++    case EM_SCORE:
++    case EM_XGATE:
++    case EM_NFP:
++    case EM_BPF:
++      return false;
++
++      /* Targets that use RELA relocations.  */
++    case EM_68K:
++    case EM_860:
++    case EM_AARCH64:
++    case EM_ADAPTEVA_EPIPHANY:
++    case EM_ALPHA:
++    case EM_ALTERA_NIOS2:
++    case EM_ARC:
++    case EM_ARC_COMPACT:
++    case EM_ARC_COMPACT2:
++    case EM_AVR:
++    case EM_AVR_OLD:
++    case EM_BLACKFIN:
++    case EM_CR16:
++    case EM_CRIS:
++    case EM_CRX:
++    case EM_CSKY:
++    case EM_D30V:
++    case EM_CYGNUS_D30V:
++    case EM_FR30:
++    case EM_FT32:
++    case EM_CYGNUS_FR30:
++    case EM_CYGNUS_FRV:
++    case EM_H8S:
++    case EM_H8_300:
++    case EM_H8_300H:
++    case EM_IA_64:
++    case EM_IP2K:
++    case EM_IP2K_OLD:
++    case EM_IQ2000:
++    case EM_LATTICEMICO32:
++    case EM_M32C_OLD:
++    case EM_M32C:
++    case EM_M32R:
++    case EM_MCORE:
++    case EM_CYGNUS_MEP:
++    case EM_METAG:
++    case EM_MMIX:
++    case EM_MN10200:
++    case EM_CYGNUS_MN10200:
++    case EM_MN10300:
++    case EM_CYGNUS_MN10300:
++    case EM_MOXIE:
++    case EM_MSP430:
++    case EM_MSP430_OLD:
++    case EM_MT:
++    case EM_NDS32:
++    case EM_NIOS32:
++    case EM_OR1K:
++    case EM_PPC64:
++    case EM_PPC:
++    case EM_TI_PRU:
++    case EM_RISCV:
++    case EM_RL78:
++    case EM_RX:
++    case EM_S390:
++    case EM_S390_OLD:
++    case EM_SH:
++    case EM_SPARC:
++    case EM_SPARC32PLUS:
++    case EM_SPARCV9:
++    case EM_SPU:
++    case EM_TI_C6000:
++    case EM_TILEGX:
++    case EM_TILEPRO:
++    case EM_V800:
++    case EM_V850:
++    case EM_CYGNUS_V850:
++    case EM_VAX:
++    case EM_VISIUM:
++    case EM_X86_64:
++    case EM_L1OM:
++    case EM_K1OM:
++    case EM_XSTORMY16:
++    case EM_XTENSA:
++    case EM_XTENSA_OLD:
++    case EM_MICROBLAZE:
++    case EM_MICROBLAZE_OLD:
++    case EM_WEBASSEMBLY:
++      return true;
++
++    case EM_68HC05:
++    case EM_68HC08:
++    case EM_68HC11:
++    case EM_68HC16:
++    case EM_FX66:
++    case EM_ME16:
++    case EM_MMA:
++    case EM_NCPU:
++    case EM_NDR1:
++    case EM_PCP:
++    case EM_ST100:
++    case EM_ST19:
++    case EM_ST7:
++    case EM_ST9PLUS:
++    case EM_STARCORE:
++    case EM_SVX:
++    case EM_TINYJ:
++    default:
++      warn (_("Don't know about relocations on this machine architecture\n"));
++      return false;
++    }
++}
++
++/* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
++   Returns TRUE upon success, FALSE otherwise.  If successful then a
++   pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
++   and the number of relocs loaded is placed in *NRELASP.  It is the caller's
++   responsibility to free the allocated buffer.  */
++
++static bool
++slurp_rela_relocs (Filedata *            filedata,
++		   unsigned long         rel_offset,
++		   unsigned long         rel_size,
++		   Elf_Internal_Rela **  relasp,
++		   unsigned long *       nrelasp)
++{
++  Elf_Internal_Rela * relas;
++  size_t nrelas;
++  unsigned int i;
++
++  if (is_32bit_elf)
++    {
++      Elf32_External_Rela * erelas;
++
++      erelas = (Elf32_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
++                                                 rel_size, _("32-bit relocation data"));
++      if (!erelas)
++	return false;
++
++      nrelas = rel_size / sizeof (Elf32_External_Rela);
++
++      relas = (Elf_Internal_Rela *) cmalloc (nrelas,
++                                             sizeof (Elf_Internal_Rela));
++
++      if (relas == NULL)
++	{
++	  free (erelas);
++	  error (_("out of memory parsing relocs\n"));
++	  return false;
++	}
++
++      for (i = 0; i < nrelas; i++)
++	{
++	  relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
++	  relas[i].r_info   = BYTE_GET (erelas[i].r_info);
++	  relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
++	}
++
++      free (erelas);
++    }
++  else
++    {
++      Elf64_External_Rela * erelas;
++
++      erelas = (Elf64_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
++                                                 rel_size, _("64-bit relocation data"));
++      if (!erelas)
++	return false;
++
++      nrelas = rel_size / sizeof (Elf64_External_Rela);
++
++      relas = (Elf_Internal_Rela *) cmalloc (nrelas,
++                                             sizeof (Elf_Internal_Rela));
++
++      if (relas == NULL)
++	{
++	  free (erelas);
++	  error (_("out of memory parsing relocs\n"));
++	  return false;
++	}
++
++      for (i = 0; i < nrelas; i++)
++	{
++	  relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
++	  relas[i].r_info   = BYTE_GET (erelas[i].r_info);
++	  relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
++
++	  /* The #ifdef BFD64 below is to prevent a compile time
++	     warning.  We know that if we do not have a 64 bit data
++	     type that we will never execute this code anyway.  */
++#ifdef BFD64
++	  if (filedata->file_header.e_machine == EM_MIPS
++	      && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
++	    {
++	      /* In little-endian objects, r_info isn't really a
++		 64-bit little-endian value: it has a 32-bit
++		 little-endian symbol index followed by four
++		 individual byte fields.  Reorder INFO
++		 accordingly.  */
++	      bfd_vma inf = relas[i].r_info;
++	      inf = (((inf & 0xffffffff) << 32)
++		      | ((inf >> 56) & 0xff)
++		      | ((inf >> 40) & 0xff00)
++		      | ((inf >> 24) & 0xff0000)
++		      | ((inf >> 8) & 0xff000000));
++	      relas[i].r_info = inf;
++	    }
++#endif /* BFD64 */
++	}
++
++      free (erelas);
++    }
++
++  *relasp = relas;
++  *nrelasp = nrelas;
++  return true;
++}
++
++/* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
++   Returns TRUE upon success, FALSE otherwise.  If successful then a
++   pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
++   and the number of relocs loaded is placed in *NRELSP.  It is the caller's
++   responsibility to free the allocated buffer.  */
++
++static bool
++slurp_rel_relocs (Filedata *            filedata,
++		  unsigned long         rel_offset,
++		  unsigned long         rel_size,
++		  Elf_Internal_Rela **  relsp,
++		  unsigned long *       nrelsp)
++{
++  Elf_Internal_Rela * rels;
++  size_t nrels;
++  unsigned int i;
++
++  if (is_32bit_elf)
++    {
++      Elf32_External_Rel * erels;
++
++      erels = (Elf32_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
++                                               rel_size, _("32-bit relocation data"));
++      if (!erels)
++	return false;
++
++      nrels = rel_size / sizeof (Elf32_External_Rel);
++
++      rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
++
++      if (rels == NULL)
++	{
++	  free (erels);
++	  error (_("out of memory parsing relocs\n"));
++	  return false;
++	}
++
++      for (i = 0; i < nrels; i++)
++	{
++	  rels[i].r_offset = BYTE_GET (erels[i].r_offset);
++	  rels[i].r_info   = BYTE_GET (erels[i].r_info);
++	  rels[i].r_addend = 0;
++	}
++
++      free (erels);
++    }
++  else
++    {
++      Elf64_External_Rel * erels;
++
++      erels = (Elf64_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
++                                               rel_size, _("64-bit relocation data"));
++      if (!erels)
++	return false;
++
++      nrels = rel_size / sizeof (Elf64_External_Rel);
++
++      rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
++
++      if (rels == NULL)
++	{
++	  free (erels);
++	  error (_("out of memory parsing relocs\n"));
++	  return false;
++	}
++
++      for (i = 0; i < nrels; i++)
++	{
++	  rels[i].r_offset = BYTE_GET (erels[i].r_offset);
++	  rels[i].r_info   = BYTE_GET (erels[i].r_info);
++	  rels[i].r_addend = 0;
++
++	  /* The #ifdef BFD64 below is to prevent a compile time
++	     warning.  We know that if we do not have a 64 bit data
++	     type that we will never execute this code anyway.  */
++#ifdef BFD64
++	  if (filedata->file_header.e_machine == EM_MIPS
++	      && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
++	    {
++	      /* In little-endian objects, r_info isn't really a
++		 64-bit little-endian value: it has a 32-bit
++		 little-endian symbol index followed by four
++		 individual byte fields.  Reorder INFO
++		 accordingly.  */
++	      bfd_vma inf = rels[i].r_info;
++	      inf = (((inf & 0xffffffff) << 32)
++		     | ((inf >> 56) & 0xff)
++		     | ((inf >> 40) & 0xff00)
++		     | ((inf >> 24) & 0xff0000)
++		     | ((inf >> 8) & 0xff000000));
++	      rels[i].r_info = inf;
++	    }
++#endif /* BFD64 */
++	}
++
++      free (erels);
++    }
++
++  *relsp = rels;
++  *nrelsp = nrels;
++  return true;
++}
++
++/* Returns the reloc type extracted from the reloc info field.  */
++
++static unsigned int
++get_reloc_type (Filedata * filedata, bfd_vma reloc_info)
++{
++  if (is_32bit_elf)
++    return ELF32_R_TYPE (reloc_info);
++
++  switch (filedata->file_header.e_machine)
++    {
++    case EM_MIPS:
++      /* Note: We assume that reloc_info has already been adjusted for us.  */
++      return ELF64_MIPS_R_TYPE (reloc_info);
++
++    case EM_SPARCV9:
++      return ELF64_R_TYPE_ID (reloc_info);
++
++    default:
++      return ELF64_R_TYPE (reloc_info);
++    }
++}
++
++/* Return the symbol index extracted from the reloc info field.  */
++
++static bfd_vma
++get_reloc_symindex (bfd_vma reloc_info)
++{
++  return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
++}
++
++static inline bool
++uses_msp430x_relocs (Filedata * filedata)
++{
++  return
++    filedata->file_header.e_machine == EM_MSP430 /* Paranoia.  */
++    /* GCC uses osabi == ELFOSBI_STANDALONE.  */
++    && (((filedata->file_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
++	/* TI compiler uses ELFOSABI_NONE.  */
++	|| (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
++}
++
++/* Display the contents of the relocation data found at the specified
++   offset.  */
++
++static bool
++dump_relocations (Filedata *          filedata,
++		  unsigned long       rel_offset,
++		  unsigned long       rel_size,
++		  Elf_Internal_Sym *  symtab,
++		  unsigned long       nsyms,
++		  char *              strtab,
++		  unsigned long       strtablen,
++		  int                 is_rela,
++		  bool                is_dynsym)
++{
++  unsigned long i;
++  Elf_Internal_Rela * rels;
++  bool res = true;
++
++  if (is_rela == UNKNOWN)
++    is_rela = guess_is_rela (filedata->file_header.e_machine);
++
++  if (is_rela)
++    {
++      if (!slurp_rela_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
++	return false;
++    }
++  else
++    {
++      if (!slurp_rel_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
++	return false;
++    }
++
++  if (is_32bit_elf)
++    {
++      if (is_rela)
++	{
++	  if (do_wide)
++	    printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
++	  else
++	    printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
++	}
++      else
++	{
++	  if (do_wide)
++	    printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
++	  else
++	    printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
++	}
++    }
++  else
++    {
++      if (is_rela)
++	{
++	  if (do_wide)
++	    printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
++	  else
++	    printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
++	}
++      else
++	{
++	  if (do_wide)
++	    printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
++	  else
++	    printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
++	}
++    }
++
++  for (i = 0; i < rel_size; i++)
++    {
++      const char * rtype;
++      bfd_vma offset;
++      bfd_vma inf;
++      bfd_vma symtab_index;
++      bfd_vma type;
++
++      offset = rels[i].r_offset;
++      inf    = rels[i].r_info;
++
++      type = get_reloc_type (filedata, inf);
++      symtab_index = get_reloc_symindex  (inf);
++
++      if (is_32bit_elf)
++	{
++	  printf ("%8.8lx  %8.8lx ",
++		  (unsigned long) offset & 0xffffffff,
++		  (unsigned long) inf & 0xffffffff);
++	}
++      else
++	{
++	  printf (do_wide
++		  ? "%16.16" BFD_VMA_FMT "x  %16.16" BFD_VMA_FMT "x "
++		  : "%12.12" BFD_VMA_FMT "x  %12.12" BFD_VMA_FMT "x ",
++		  offset, inf);
++	}
++
++      switch (filedata->file_header.e_machine)
++	{
++	default:
++	  rtype = NULL;
++	  break;
++
++	case EM_AARCH64:
++	  rtype = elf_aarch64_reloc_type (type);
++	  break;
++
++	case EM_M32R:
++	case EM_CYGNUS_M32R:
++	  rtype = elf_m32r_reloc_type (type);
++	  break;
++
++	case EM_386:
++	case EM_IAMCU:
++	  rtype = elf_i386_reloc_type (type);
++	  break;
++
++	case EM_68HC11:
++	case EM_68HC12:
++	  rtype = elf_m68hc11_reloc_type (type);
++	  break;
++
++	case EM_S12Z:
++	  rtype = elf_s12z_reloc_type (type);
++	  break;
++
++	case EM_68K:
++	  rtype = elf_m68k_reloc_type (type);
++	  break;
++
++	case EM_960:
++	  rtype = elf_i960_reloc_type (type);
++	  break;
++
++	case EM_AVR:
++	case EM_AVR_OLD:
++	  rtype = elf_avr_reloc_type (type);
++	  break;
++
++	case EM_OLD_SPARCV9:
++	case EM_SPARC32PLUS:
++	case EM_SPARCV9:
++	case EM_SPARC:
++	  rtype = elf_sparc_reloc_type (type);
++	  break;
++
++	case EM_SPU:
++	  rtype = elf_spu_reloc_type (type);
++	  break;
++
++	case EM_V800:
++	  rtype = v800_reloc_type (type);
++	  break;
++	case EM_V850:
++	case EM_CYGNUS_V850:
++	  rtype = v850_reloc_type (type);
++	  break;
++
++	case EM_D10V:
++	case EM_CYGNUS_D10V:
++	  rtype = elf_d10v_reloc_type (type);
++	  break;
++
++	case EM_D30V:
++	case EM_CYGNUS_D30V:
++	  rtype = elf_d30v_reloc_type (type);
++	  break;
++
++	case EM_DLX:
++	  rtype = elf_dlx_reloc_type (type);
++	  break;
++
++	case EM_SH:
++	  rtype = elf_sh_reloc_type (type);
++	  break;
++
++	case EM_MN10300:
++	case EM_CYGNUS_MN10300:
++	  rtype = elf_mn10300_reloc_type (type);
++	  break;
++
++	case EM_MN10200:
++	case EM_CYGNUS_MN10200:
++	  rtype = elf_mn10200_reloc_type (type);
++	  break;
++
++	case EM_FR30:
++	case EM_CYGNUS_FR30:
++	  rtype = elf_fr30_reloc_type (type);
++	  break;
++
++	case EM_CYGNUS_FRV:
++	  rtype = elf_frv_reloc_type (type);
++	  break;
++
++	case EM_CSKY:
++	  rtype = elf_csky_reloc_type (type);
++	  break;
++
++	case EM_FT32:
++	  rtype = elf_ft32_reloc_type (type);
++	  break;
++
++	case EM_MCORE:
++	  rtype = elf_mcore_reloc_type (type);
++	  break;
++
++	case EM_MMIX:
++	  rtype = elf_mmix_reloc_type (type);
++	  break;
++
++	case EM_MOXIE:
++	  rtype = elf_moxie_reloc_type (type);
++	  break;
++
++	case EM_MSP430:
++	  if (uses_msp430x_relocs (filedata))
++	    {
++	      rtype = elf_msp430x_reloc_type (type);
++	      break;
++	    }
++	  /* Fall through.  */
++	case EM_MSP430_OLD:
++	  rtype = elf_msp430_reloc_type (type);
++	  break;
++
++	case EM_NDS32:
++	  rtype = elf_nds32_reloc_type (type);
++	  break;
++
++	case EM_PPC:
++	  rtype = elf_ppc_reloc_type (type);
++	  break;
++
++	case EM_PPC64:
++	  rtype = elf_ppc64_reloc_type (type);
++	  break;
++
++	case EM_MIPS:
++	case EM_MIPS_RS3_LE:
++	  rtype = elf_mips_reloc_type (type);
++	  break;
++
++	case EM_RISCV:
++	  rtype = elf_riscv_reloc_type (type);
++	  break;
++
++	case EM_ALPHA:
++	  rtype = elf_alpha_reloc_type (type);
++	  break;
++
++	case EM_ARM:
++	  rtype = elf_arm_reloc_type (type);
++	  break;
++
++	case EM_ARC:
++	case EM_ARC_COMPACT:
++	case EM_ARC_COMPACT2:
++	  rtype = elf_arc_reloc_type (type);
++	  break;
++
++	case EM_PARISC:
++	  rtype = elf_hppa_reloc_type (type);
++	  break;
++
++	case EM_H8_300:
++	case EM_H8_300H:
++	case EM_H8S:
++	  rtype = elf_h8_reloc_type (type);
++	  break;
++
++	case EM_OR1K:
++	  rtype = elf_or1k_reloc_type (type);
++	  break;
++
++	case EM_PJ:
++	case EM_PJ_OLD:
++	  rtype = elf_pj_reloc_type (type);
++	  break;
++	case EM_IA_64:
++	  rtype = elf_ia64_reloc_type (type);
++	  break;
++
++	case EM_CRIS:
++	  rtype = elf_cris_reloc_type (type);
++	  break;
++
++	case EM_860:
++	  rtype = elf_i860_reloc_type (type);
++	  break;
++
++	case EM_X86_64:
++	case EM_L1OM:
++	case EM_K1OM:
++	  rtype = elf_x86_64_reloc_type (type);
++	  break;
++
++	case EM_S370:
++	  rtype = i370_reloc_type (type);
++	  break;
++
++	case EM_S390_OLD:
++	case EM_S390:
++	  rtype = elf_s390_reloc_type (type);
++	  break;
++
++	case EM_SCORE:
++	  rtype = elf_score_reloc_type (type);
++	  break;
++
++	case EM_XSTORMY16:
++	  rtype = elf_xstormy16_reloc_type (type);
++	  break;
++
++	case EM_CRX:
++	  rtype = elf_crx_reloc_type (type);
++	  break;
++
++	case EM_VAX:
++	  rtype = elf_vax_reloc_type (type);
++	  break;
++
++	case EM_VISIUM:
++	  rtype = elf_visium_reloc_type (type);
++	  break;
++
++        case EM_BPF:
++          rtype = elf_bpf_reloc_type (type);
++          break;
++
++	case EM_ADAPTEVA_EPIPHANY:
++	  rtype = elf_epiphany_reloc_type (type);
++	  break;
++
++	case EM_IP2K:
++	case EM_IP2K_OLD:
++	  rtype = elf_ip2k_reloc_type (type);
++	  break;
++
++	case EM_IQ2000:
++	  rtype = elf_iq2000_reloc_type (type);
++	  break;
++
++	case EM_XTENSA_OLD:
++	case EM_XTENSA:
++	  rtype = elf_xtensa_reloc_type (type);
++	  break;
++
++	case EM_LATTICEMICO32:
++	  rtype = elf_lm32_reloc_type (type);
++	  break;
++
++	case EM_M32C_OLD:
++	case EM_M32C:
++	  rtype = elf_m32c_reloc_type (type);
++	  break;
++
++	case EM_MT:
++	  rtype = elf_mt_reloc_type (type);
++	  break;
++
++	case EM_BLACKFIN:
++	  rtype = elf_bfin_reloc_type (type);
++	  break;
++
++	case EM_CYGNUS_MEP:
++	  rtype = elf_mep_reloc_type (type);
++	  break;
++
++	case EM_CR16:
++	  rtype = elf_cr16_reloc_type (type);
++	  break;
++
++	case EM_MICROBLAZE:
++	case EM_MICROBLAZE_OLD:
++	  rtype = elf_microblaze_reloc_type (type);
++	  break;
++
++	case EM_RL78:
++	  rtype = elf_rl78_reloc_type (type);
++	  break;
++
++	case EM_RX:
++	  rtype = elf_rx_reloc_type (type);
++	  break;
++
++	case EM_METAG:
++	  rtype = elf_metag_reloc_type (type);
++	  break;
++
++	case EM_XC16X:
++	case EM_C166:
++	  rtype = elf_xc16x_reloc_type (type);
++	  break;
++
++	case EM_TI_C6000:
++	  rtype = elf_tic6x_reloc_type (type);
++	  break;
++
++	case EM_TILEGX:
++	  rtype = elf_tilegx_reloc_type (type);
++	  break;
++
++	case EM_TILEPRO:
++	  rtype = elf_tilepro_reloc_type (type);
++	  break;
++
++	case EM_WEBASSEMBLY:
++	  rtype = elf_wasm32_reloc_type (type);
++	  break;
++
++	case EM_XGATE:
++	  rtype = elf_xgate_reloc_type (type);
++	  break;
++
++	case EM_ALTERA_NIOS2:
++	  rtype = elf_nios2_reloc_type (type);
++	  break;
++
++	case EM_TI_PRU:
++	  rtype = elf_pru_reloc_type (type);
++	  break;
++
++	case EM_NFP:
++	  if (EF_NFP_MACH (filedata->file_header.e_flags) == E_NFP_MACH_3200)
++	    rtype = elf_nfp3200_reloc_type (type);
++	  else
++	    rtype = elf_nfp_reloc_type (type);
++	  break;
++
++	case EM_Z80:
++	  rtype = elf_z80_reloc_type (type);
++	  break;
++	}
++
++      if (rtype == NULL)
++	printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
++      else
++	printf (do_wide ? "%-22s" : "%-17.17s", rtype);
++
++      if (filedata->file_header.e_machine == EM_ALPHA
++	  && rtype != NULL
++	  && streq (rtype, "R_ALPHA_LITUSE")
++	  && is_rela)
++	{
++	  switch (rels[i].r_addend)
++	    {
++	    case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
++	    case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
++	    case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
++	    case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
++	    case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
++	    case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
++	    case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
++	    default: rtype = NULL;
++	    }
++
++	  if (rtype)
++	    printf (" (%s)", rtype);
++	  else
++	    {
++	      putchar (' ');
++	      printf (_("<unknown addend: %lx>"),
++		      (unsigned long) rels[i].r_addend);
++	      res = false;
++	    }
++	}
++      else if (symtab_index)
++	{
++	  if (symtab == NULL || symtab_index >= nsyms)
++	    {
++	      error (_(" bad symbol index: %08lx in reloc\n"),
++		     (unsigned long) symtab_index);
++	      res = false;
++	    }
++	  else
++	    {
++	      Elf_Internal_Sym * psym;
++	      const char * version_string;
++	      enum versioned_symbol_info sym_info;
++	      unsigned short vna_other;
++
++	      psym = symtab + symtab_index;
++
++	      version_string
++		= get_symbol_version_string (filedata, is_dynsym,
++					     strtab, strtablen,
++					     symtab_index,
++					     psym,
++					     &sym_info,
++					     &vna_other);
++
++	      printf (" ");
++
++	      if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
++		{
++		  const char * name;
++		  unsigned int len;
++		  unsigned int width = is_32bit_elf ? 8 : 14;
++
++		  /* Relocations against GNU_IFUNC symbols do not use the value
++		     of the symbol as the address to relocate against.  Instead
++		     they invoke the function named by the symbol and use its
++		     result as the address for relocation.
++
++		     To indicate this to the user, do not display the value of
++		     the symbol in the "Symbols's Value" field.  Instead show
++		     its name followed by () as a hint that the symbol is
++		     invoked.  */
++
++		  if (strtab == NULL
++		      || psym->st_name == 0
++		      || psym->st_name >= strtablen)
++		    name = "??";
++		  else
++		    name = strtab + psym->st_name;
++
++		  len = print_symbol (width, name);
++		  if (version_string)
++		    printf (sym_info == symbol_public ? "@@%s" : "@%s",
++			    version_string);
++		  printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
++		}
++	      else
++		{
++		  print_vma (psym->st_value, LONG_HEX);
++
++		  printf (is_32bit_elf ? "   " : " ");
++		}
++
++	      if (psym->st_name == 0)
++		{
++		  const char * sec_name = "<null>";
++		  char name_buf[40];
++
++		  if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
++		    {
++		      if (psym->st_shndx < filedata->file_header.e_shnum)
++			sec_name = SECTION_NAME_PRINT (filedata->section_headers
++						       + psym->st_shndx);
++		      else if (psym->st_shndx == SHN_ABS)
++			sec_name = "ABS";
++		      else if (psym->st_shndx == SHN_COMMON)
++			sec_name = "COMMON";
++		      else if ((filedata->file_header.e_machine == EM_MIPS
++				&& psym->st_shndx == SHN_MIPS_SCOMMON)
++			       || (filedata->file_header.e_machine == EM_TI_C6000
++				   && psym->st_shndx == SHN_TIC6X_SCOMMON))
++			sec_name = "SCOMMON";
++		      else if (filedata->file_header.e_machine == EM_MIPS
++			       && psym->st_shndx == SHN_MIPS_SUNDEFINED)
++			sec_name = "SUNDEF";
++		      else if ((filedata->file_header.e_machine == EM_X86_64
++				|| filedata->file_header.e_machine == EM_L1OM
++				|| filedata->file_header.e_machine == EM_K1OM)
++			       && psym->st_shndx == SHN_X86_64_LCOMMON)
++			sec_name = "LARGE_COMMON";
++		      else if (filedata->file_header.e_machine == EM_IA_64
++			       && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
++			       && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
++			sec_name = "ANSI_COM";
++		      else if (is_ia64_vms (filedata)
++			       && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
++			sec_name = "VMS_SYMVEC";
++		      else
++			{
++			  sprintf (name_buf, "<section 0x%x>",
++				   (unsigned int) psym->st_shndx);
++			  sec_name = name_buf;
++			}
++		    }
++		  print_symbol (22, sec_name);
++		}
++	      else if (strtab == NULL)
++		printf (_("<string table index: %3ld>"), psym->st_name);
++	      else if (psym->st_name >= strtablen)
++		{
++		  error (_("<corrupt string table index: %3ld>\n"),
++			 psym->st_name);
++		  res = false;
++		}
++	      else
++		{
++		  print_symbol (22, strtab + psym->st_name);
++		  if (version_string)
++		    printf (sym_info == symbol_public ? "@@%s" : "@%s",
++			    version_string);
++		}
++
++	      if (is_rela)
++		{
++		  bfd_vma off = rels[i].r_addend;
++
++		  if ((bfd_signed_vma) off < 0)
++		    printf (" - %" BFD_VMA_FMT "x", - off);
++		  else
++		    printf (" + %" BFD_VMA_FMT "x", off);
++		}
++	    }
++	}
++      else if (is_rela)
++	{
++	  bfd_vma off = rels[i].r_addend;
++
++	  printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
++	  if ((bfd_signed_vma) off < 0)
++	    printf ("-%" BFD_VMA_FMT "x", - off);
++	  else
++	    printf ("%" BFD_VMA_FMT "x", off);
++	}
++
++      if (filedata->file_header.e_machine == EM_SPARCV9
++	  && rtype != NULL
++	  && streq (rtype, "R_SPARC_OLO10"))
++	printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
++
++      putchar ('\n');
++
++#ifdef BFD64
++      if (! is_32bit_elf && filedata->file_header.e_machine == EM_MIPS)
++	{
++	  bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
++	  bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
++	  const char * rtype2 = elf_mips_reloc_type (type2);
++	  const char * rtype3 = elf_mips_reloc_type (type3);
++
++	  printf ("                    Type2: ");
++
++	  if (rtype2 == NULL)
++	    printf (_("unrecognized: %-7lx"),
++		    (unsigned long) type2 & 0xffffffff);
++	  else
++	    printf ("%-17.17s", rtype2);
++
++	  printf ("\n                    Type3: ");
++
++	  if (rtype3 == NULL)
++	    printf (_("unrecognized: %-7lx"),
++		    (unsigned long) type3 & 0xffffffff);
++	  else
++	    printf ("%-17.17s", rtype3);
++
++	  putchar ('\n');
++	}
++#endif /* BFD64 */
++    }
++
++  free (rels);
++
++  return res;
++}
++
++static const char *
++get_aarch64_dynamic_type (unsigned long type)
++{
++  switch (type)
++    {
++    case DT_AARCH64_BTI_PLT:  return "AARCH64_BTI_PLT";
++    case DT_AARCH64_PAC_PLT:  return "AARCH64_PAC_PLT";
++    case DT_AARCH64_VARIANT_PCS:  return "AARCH64_VARIANT_PCS";
++    default:
++      return NULL;
++    }
++}
++
++static const char *
++get_mips_dynamic_type (unsigned long type)
++{
++  switch (type)
++    {
++    case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
++    case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
++    case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
++    case DT_MIPS_IVERSION: return "MIPS_IVERSION";
++    case DT_MIPS_FLAGS: return "MIPS_FLAGS";
++    case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
++    case DT_MIPS_MSYM: return "MIPS_MSYM";
++    case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
++    case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
++    case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
++    case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
++    case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
++    case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
++    case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
++    case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
++    case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
++    case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
++    case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
++    case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
++    case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
++    case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
++    case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
++    case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
++    case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
++    case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
++    case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
++    case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
++    case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
++    case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
++    case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
++    case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
++    case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
++    case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
++    case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
++    case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
++    case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
++    case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
++    case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
++    case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
++    case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
++    case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
++    case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
++    case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
++    case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
++    case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
++    case DT_MIPS_RWPLT: return "MIPS_RWPLT";
++    case DT_MIPS_XHASH: return "MIPS_XHASH";
++    default:
++      return NULL;
++    }
++}
++
++static const char *
++get_sparc64_dynamic_type (unsigned long type)
++{
++  switch (type)
++    {
++    case DT_SPARC_REGISTER: return "SPARC_REGISTER";
++    default:
++      return NULL;
++    }
++}
++
++static const char *
++get_ppc_dynamic_type (unsigned long type)
++{
++  switch (type)
++    {
++    case DT_PPC_GOT:    return "PPC_GOT";
++    case DT_PPC_OPT:    return "PPC_OPT";
++    default:
++      return NULL;
++    }
++}
++
++static const char *
++get_ppc64_dynamic_type (unsigned long type)
++{
++  switch (type)
++    {
++    case DT_PPC64_GLINK:  return "PPC64_GLINK";
++    case DT_PPC64_OPD:    return "PPC64_OPD";
++    case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
++    case DT_PPC64_OPT:    return "PPC64_OPT";
++    default:
++      return NULL;
++    }
++}
++
++static const char *
++get_parisc_dynamic_type (unsigned long type)
++{
++  switch (type)
++    {
++    case DT_HP_LOAD_MAP:	return "HP_LOAD_MAP";
++    case DT_HP_DLD_FLAGS:	return "HP_DLD_FLAGS";
++    case DT_HP_DLD_HOOK:	return "HP_DLD_HOOK";
++    case DT_HP_UX10_INIT:	return "HP_UX10_INIT";
++    case DT_HP_UX10_INITSZ:	return "HP_UX10_INITSZ";
++    case DT_HP_PREINIT:		return "HP_PREINIT";
++    case DT_HP_PREINITSZ:	return "HP_PREINITSZ";
++    case DT_HP_NEEDED:		return "HP_NEEDED";
++    case DT_HP_TIME_STAMP:	return "HP_TIME_STAMP";
++    case DT_HP_CHECKSUM:	return "HP_CHECKSUM";
++    case DT_HP_GST_SIZE:	return "HP_GST_SIZE";
++    case DT_HP_GST_VERSION:	return "HP_GST_VERSION";
++    case DT_HP_GST_HASHVAL:	return "HP_GST_HASHVAL";
++    case DT_HP_EPLTREL:		return "HP_GST_EPLTREL";
++    case DT_HP_EPLTRELSZ:	return "HP_GST_EPLTRELSZ";
++    case DT_HP_FILTERED:	return "HP_FILTERED";
++    case DT_HP_FILTER_TLS:	return "HP_FILTER_TLS";
++    case DT_HP_COMPAT_FILTERED:	return "HP_COMPAT_FILTERED";
++    case DT_HP_LAZYLOAD:	return "HP_LAZYLOAD";
++    case DT_HP_BIND_NOW_COUNT:	return "HP_BIND_NOW_COUNT";
++    case DT_PLT:		return "PLT";
++    case DT_PLT_SIZE:		return "PLT_SIZE";
++    case DT_DLT:		return "DLT";
++    case DT_DLT_SIZE:		return "DLT_SIZE";
++    default:
++      return NULL;
++    }
++}
++
++static const char *
++get_ia64_dynamic_type (unsigned long type)
++{
++  switch (type)
++    {
++    case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
++    case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
++    case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
++    case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
++    case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
++    case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
++    case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
++    case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
++    case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
++    case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
++    case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
++    case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
++    case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
++    case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
++    case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
++    case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
++    case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
++    case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
++    case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
++    case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
++    case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
++    case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
++    case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
++    case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
++    case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
++    case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
++    case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
++    case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
++    case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
++    case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
++    case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
++    default:
++      return NULL;
++    }
++}
++
++static const char *
++get_solaris_section_type (unsigned long type)
++{
++  switch (type)
++    {
++    case 0x6fffffee: return "SUNW_ancillary";
++    case 0x6fffffef: return "SUNW_capchain";
++    case 0x6ffffff0: return "SUNW_capinfo";
++    case 0x6ffffff1: return "SUNW_symsort";
++    case 0x6ffffff2: return "SUNW_tlssort";
++    case 0x6ffffff3: return "SUNW_LDYNSYM";
++    case 0x6ffffff4: return "SUNW_dof";
++    case 0x6ffffff5: return "SUNW_cap";
++    case 0x6ffffff6: return "SUNW_SIGNATURE";
++    case 0x6ffffff7: return "SUNW_ANNOTATE";
++    case 0x6ffffff8: return "SUNW_DEBUGSTR";
++    case 0x6ffffff9: return "SUNW_DEBUG";
++    case 0x6ffffffa: return "SUNW_move";
++    case 0x6ffffffb: return "SUNW_COMDAT";
++    case 0x6ffffffc: return "SUNW_syminfo";
++    case 0x6ffffffd: return "SUNW_verdef";
++    case 0x6ffffffe: return "SUNW_verneed";
++    case 0x6fffffff: return "SUNW_versym";
++    case 0x70000000: return "SPARC_GOTDATA";
++    default: return NULL;
++    }
++}
++
++static const char *
++get_alpha_dynamic_type (unsigned long type)
++{
++  switch (type)
++    {
++    case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
++    default: return NULL;
++    }
++}
++
++static const char *
++get_score_dynamic_type (unsigned long type)
++{
++  switch (type)
++    {
++    case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
++    case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
++    case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
++    case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
++    case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
++    case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
++    default:                    return NULL;
++    }
++}
++
++static const char *
++get_tic6x_dynamic_type (unsigned long type)
++{
++  switch (type)
++    {
++    case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
++    case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
++    case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
++    case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
++    case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
++    case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
++    default:                   return NULL;
++    }
++}
++
++static const char *
++get_nios2_dynamic_type (unsigned long type)
++{
++  switch (type)
++    {
++    case DT_NIOS2_GP: return "NIOS2_GP";
++    default:          return NULL;
++    }
++}
++
++static const char *
++get_solaris_dynamic_type (unsigned long type)
++{
++  switch (type)
++    {
++    case 0x6000000d: return "SUNW_AUXILIARY";
++    case 0x6000000e: return "SUNW_RTLDINF";
++    case 0x6000000f: return "SUNW_FILTER";
++    case 0x60000010: return "SUNW_CAP";
++    case 0x60000011: return "SUNW_SYMTAB";
++    case 0x60000012: return "SUNW_SYMSZ";
++    case 0x60000013: return "SUNW_SORTENT";
++    case 0x60000014: return "SUNW_SYMSORT";
++    case 0x60000015: return "SUNW_SYMSORTSZ";
++    case 0x60000016: return "SUNW_TLSSORT";
++    case 0x60000017: return "SUNW_TLSSORTSZ";
++    case 0x60000018: return "SUNW_CAPINFO";
++    case 0x60000019: return "SUNW_STRPAD";
++    case 0x6000001a: return "SUNW_CAPCHAIN";
++    case 0x6000001b: return "SUNW_LDMACH";
++    case 0x6000001d: return "SUNW_CAPCHAINENT";
++    case 0x6000001f: return "SUNW_CAPCHAINSZ";
++    case 0x60000021: return "SUNW_PARENT";
++    case 0x60000023: return "SUNW_ASLR";
++    case 0x60000025: return "SUNW_RELAX";
++    case 0x60000029: return "SUNW_NXHEAP";
++    case 0x6000002b: return "SUNW_NXSTACK";
++
++    case 0x70000001: return "SPARC_REGISTER";
++    case 0x7ffffffd: return "AUXILIARY";
++    case 0x7ffffffe: return "USED";
++    case 0x7fffffff: return "FILTER";
++
++    default: return NULL;
++    }
++}
++
++static const char *
++get_dynamic_type (Filedata * filedata, unsigned long type)
++{
++  static char buff[64];
++
++  switch (type)
++    {
++    case DT_NULL:	return "NULL";
++    case DT_NEEDED:	return "NEEDED";
++    case DT_PLTRELSZ:	return "PLTRELSZ";
++    case DT_PLTGOT:	return "PLTGOT";
++    case DT_HASH:	return "HASH";
++    case DT_STRTAB:	return "STRTAB";
++    case DT_SYMTAB:	return "SYMTAB";
++    case DT_RELA:	return "RELA";
++    case DT_RELASZ:	return "RELASZ";
++    case DT_RELAENT:	return "RELAENT";
++    case DT_STRSZ:	return "STRSZ";
++    case DT_SYMENT:	return "SYMENT";
++    case DT_INIT:	return "INIT";
++    case DT_FINI:	return "FINI";
++    case DT_SONAME:	return "SONAME";
++    case DT_RPATH:	return "RPATH";
++    case DT_SYMBOLIC:	return "SYMBOLIC";
++    case DT_REL:	return "REL";
++    case DT_RELSZ:	return "RELSZ";
++    case DT_RELENT:	return "RELENT";
++    case DT_PLTREL:	return "PLTREL";
++    case DT_DEBUG:	return "DEBUG";
++    case DT_TEXTREL:	return "TEXTREL";
++    case DT_JMPREL:	return "JMPREL";
++    case DT_BIND_NOW:   return "BIND_NOW";
++    case DT_INIT_ARRAY: return "INIT_ARRAY";
++    case DT_FINI_ARRAY: return "FINI_ARRAY";
++    case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
++    case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
++    case DT_RUNPATH:    return "RUNPATH";
++    case DT_FLAGS:      return "FLAGS";
++
++    case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
++    case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
++    case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
++
++    case DT_CHECKSUM:	return "CHECKSUM";
++    case DT_PLTPADSZ:	return "PLTPADSZ";
++    case DT_MOVEENT:	return "MOVEENT";
++    case DT_MOVESZ:	return "MOVESZ";
++    case DT_FEATURE:	return "FEATURE";
++    case DT_POSFLAG_1:	return "POSFLAG_1";
++    case DT_SYMINSZ:	return "SYMINSZ";
++    case DT_SYMINENT:	return "SYMINENT"; /* aka VALRNGHI */
++
++    case DT_ADDRRNGLO:  return "ADDRRNGLO";
++    case DT_CONFIG:	return "CONFIG";
++    case DT_DEPAUDIT:	return "DEPAUDIT";
++    case DT_AUDIT:	return "AUDIT";
++    case DT_PLTPAD:	return "PLTPAD";
++    case DT_MOVETAB:	return "MOVETAB";
++    case DT_SYMINFO:	return "SYMINFO"; /* aka ADDRRNGHI */
++
++    case DT_VERSYM:	return "VERSYM";
++
++    case DT_TLSDESC_GOT: return "TLSDESC_GOT";
++    case DT_TLSDESC_PLT: return "TLSDESC_PLT";
++    case DT_RELACOUNT:	return "RELACOUNT";
++    case DT_RELCOUNT:	return "RELCOUNT";
++    case DT_FLAGS_1:	return "FLAGS_1";
++    case DT_VERDEF:	return "VERDEF";
++    case DT_VERDEFNUM:	return "VERDEFNUM";
++    case DT_VERNEED:	return "VERNEED";
++    case DT_VERNEEDNUM:	return "VERNEEDNUM";
++
++    case DT_AUXILIARY:	return "AUXILIARY";
++    case DT_USED:	return "USED";
++    case DT_FILTER:	return "FILTER";
++
++    case DT_GNU_PRELINKED: return "GNU_PRELINKED";
++    case DT_GNU_CONFLICT: return "GNU_CONFLICT";
++    case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
++    case DT_GNU_LIBLIST: return "GNU_LIBLIST";
++    case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
++    case DT_GNU_HASH:	return "GNU_HASH";
++    case DT_GNU_FLAGS_1: return "GNU_FLAGS_1";
++
++    default:
++      if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
++	{
++	  const char * result;
++
++	  switch (filedata->file_header.e_machine)
++	    {
++	    case EM_AARCH64:
++	      result = get_aarch64_dynamic_type (type);
++	      break;
++	    case EM_MIPS:
++	    case EM_MIPS_RS3_LE:
++	      result = get_mips_dynamic_type (type);
++	      break;
++	    case EM_SPARCV9:
++	      result = get_sparc64_dynamic_type (type);
++	      break;
++	    case EM_PPC:
++	      result = get_ppc_dynamic_type (type);
++	      break;
++	    case EM_PPC64:
++	      result = get_ppc64_dynamic_type (type);
++	      break;
++	    case EM_IA_64:
++	      result = get_ia64_dynamic_type (type);
++	      break;
++	    case EM_ALPHA:
++	      result = get_alpha_dynamic_type (type);
++	      break;
++	    case EM_SCORE:
++	      result = get_score_dynamic_type (type);
++	      break;
++	    case EM_TI_C6000:
++	      result = get_tic6x_dynamic_type (type);
++	      break;
++	    case EM_ALTERA_NIOS2:
++	      result = get_nios2_dynamic_type (type);
++	      break;
++	    default:
++	      if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
++		result = get_solaris_dynamic_type (type);
++	      else
++		result = NULL;
++	      break;
++	    }
++
++	  if (result != NULL)
++	    return result;
++
++	  snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
++	}
++      else if (((type >= DT_LOOS) && (type <= DT_HIOS))
++	       || (filedata->file_header.e_machine == EM_PARISC
++		   && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
++	{
++	  const char * result;
++
++	  switch (filedata->file_header.e_machine)
++	    {
++	    case EM_PARISC:
++	      result = get_parisc_dynamic_type (type);
++	      break;
++	    case EM_IA_64:
++	      result = get_ia64_dynamic_type (type);
++	      break;
++	    default:
++	      if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
++		result = get_solaris_dynamic_type (type);
++	      else
++		result = NULL;
++	      break;
++	    }
++
++	  if (result != NULL)
++	    return result;
++
++	  snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
++		    type);
++	}
++      else
++	snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
++
++      return buff;
++    }
++}
++
++static bool get_program_headers (Filedata *);
++static bool get_dynamic_section (Filedata *);
++
++static void
++locate_dynamic_section (Filedata *filedata)
++{
++  unsigned long dynamic_addr = 0;
++  bfd_size_type dynamic_size = 0;
++
++  if (filedata->file_header.e_phnum != 0
++      && get_program_headers (filedata))
++    {
++      Elf_Internal_Phdr *segment;
++      unsigned int i;
++
++      for (i = 0, segment = filedata->program_headers;
++	   i < filedata->file_header.e_phnum;
++	   i++, segment++)
++	{
++	  if (segment->p_type == PT_DYNAMIC)
++	    {
++	      dynamic_addr = segment->p_offset;
++	      dynamic_size = segment->p_filesz;
++
++	      if (filedata->section_headers != NULL)
++		{
++		  Elf_Internal_Shdr *sec;
++
++		  sec = find_section (filedata, ".dynamic");
++		  if (sec != NULL)
++		    {
++		      if (sec->sh_size == 0
++			  || sec->sh_type == SHT_NOBITS)
++			{
++			  dynamic_addr = 0;
++			  dynamic_size = 0;
++			}
++		      else
++			{
++			  dynamic_addr = sec->sh_offset;
++			  dynamic_size = sec->sh_size;
++			}
++		    }
++		}
++
++	      if (dynamic_addr > filedata->file_size
++		  || (dynamic_size > filedata->file_size - dynamic_addr))
++		{
++		  dynamic_addr = 0;
++		  dynamic_size = 0;
++		}
++	      break;
++	    }
++	}
++    }
++  filedata->dynamic_addr = dynamic_addr;
++  filedata->dynamic_size = dynamic_size ? dynamic_size : 1;
++}
++
++static bool
++is_pie (Filedata *filedata)
++{
++  Elf_Internal_Dyn *entry;
++
++  if (filedata->dynamic_size == 0)
++    locate_dynamic_section (filedata);
++  if (filedata->dynamic_size <= 1)
++    return false;
++
++  if (!get_dynamic_section (filedata))
++    return false;
++
++  for (entry = filedata->dynamic_section;
++       entry < filedata->dynamic_section + filedata->dynamic_nent;
++       entry++)
++    {
++      if (entry->d_tag == DT_FLAGS_1)
++	{
++	  if ((entry->d_un.d_val & DF_1_PIE) != 0)
++	    return true;
++	  break;
++	}
++    }
++  return false;
++}
++
++static char *
++get_file_type (Filedata *filedata)
++{
++  unsigned e_type = filedata->file_header.e_type;
++  static char buff[64];
++
++  switch (e_type)
++    {
++    case ET_NONE: return _("NONE (None)");
++    case ET_REL:  return _("REL (Relocatable file)");
++    case ET_EXEC: return _("EXEC (Executable file)");
++    case ET_DYN:
++      if (is_pie (filedata))
++	return _("DYN (Position-Independent Executable file)");
++      else
++	return _("DYN (Shared object file)");
++    case ET_CORE: return _("CORE (Core file)");
++
++    default:
++      if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
++	snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
++      else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
++	snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
++      else
++	snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
++      return buff;
++    }
++}
++
++static char *
++get_machine_name (unsigned e_machine)
++{
++  static char buff[64]; /* XXX */
++
++  switch (e_machine)
++    {
++      /* Please keep this switch table sorted by increasing EM_ value.  */
++      /* 0 */
++    case EM_NONE:		return _("None");
++    case EM_M32:		return "WE32100";
++    case EM_SPARC:		return "Sparc";
++    case EM_386:		return "Intel 80386";
++    case EM_68K:		return "MC68000";
++    case EM_88K:		return "MC88000";
++    case EM_IAMCU:		return "Intel MCU";
++    case EM_860:		return "Intel 80860";
++    case EM_MIPS:		return "MIPS R3000";
++    case EM_S370:		return "IBM System/370";
++      /* 10 */
++    case EM_MIPS_RS3_LE:	return "MIPS R4000 big-endian";
++    case EM_OLD_SPARCV9:	return "Sparc v9 (old)";
++    case EM_PARISC:		return "HPPA";
++    case EM_VPP550:		return "Fujitsu VPP500";
++    case EM_SPARC32PLUS:	return "Sparc v8+" ;
++    case EM_960:		return "Intel 80960";
++    case EM_PPC:		return "PowerPC";
++      /* 20 */
++    case EM_PPC64:		return "PowerPC64";
++    case EM_S390_OLD:
++    case EM_S390:		return "IBM S/390";
++    case EM_SPU:		return "SPU";
++      /* 30 */
++    case EM_V800:		return "Renesas V850 (using RH850 ABI)";
++    case EM_FR20:		return "Fujitsu FR20";
++    case EM_RH32:		return "TRW RH32";
++    case EM_MCORE:		return "MCORE";
++      /* 40 */
++    case EM_ARM:		return "ARM";
++    case EM_OLD_ALPHA:		return "Digital Alpha (old)";
++    case EM_SH:			return "Renesas / SuperH SH";
++    case EM_SPARCV9:		return "Sparc v9";
++    case EM_TRICORE:		return "Siemens Tricore";
++    case EM_ARC:		return "ARC";
++    case EM_H8_300:		return "Renesas H8/300";
++    case EM_H8_300H:		return "Renesas H8/300H";
++    case EM_H8S:		return "Renesas H8S";
++    case EM_H8_500:		return "Renesas H8/500";
++      /* 50 */
++    case EM_IA_64:		return "Intel IA-64";
++    case EM_MIPS_X:		return "Stanford MIPS-X";
++    case EM_COLDFIRE:		return "Motorola Coldfire";
++    case EM_68HC12:		return "Motorola MC68HC12 Microcontroller";
++    case EM_MMA:		return "Fujitsu Multimedia Accelerator";
++    case EM_PCP:		return "Siemens PCP";
++    case EM_NCPU:		return "Sony nCPU embedded RISC processor";
++    case EM_NDR1:		return "Denso NDR1 microprocesspr";
++    case EM_STARCORE:		return "Motorola Star*Core processor";
++    case EM_ME16:		return "Toyota ME16 processor";
++      /* 60 */
++    case EM_ST100:		return "STMicroelectronics ST100 processor";
++    case EM_TINYJ:		return "Advanced Logic Corp. TinyJ embedded processor";
++    case EM_X86_64:		return "Advanced Micro Devices X86-64";
++    case EM_PDSP:		return "Sony DSP processor";
++    case EM_PDP10:		return "Digital Equipment Corp. PDP-10";
++    case EM_PDP11:		return "Digital Equipment Corp. PDP-11";
++    case EM_FX66:		return "Siemens FX66 microcontroller";
++    case EM_ST9PLUS:		return "STMicroelectronics ST9+ 8/16 bit microcontroller";
++    case EM_ST7:		return "STMicroelectronics ST7 8-bit microcontroller";
++    case EM_68HC16:		return "Motorola MC68HC16 Microcontroller";
++      /* 70 */
++    case EM_68HC11:		return "Motorola MC68HC11 Microcontroller";
++    case EM_68HC08:		return "Motorola MC68HC08 Microcontroller";
++    case EM_68HC05:		return "Motorola MC68HC05 Microcontroller";
++    case EM_SVX:		return "Silicon Graphics SVx";
++    case EM_ST19:		return "STMicroelectronics ST19 8-bit microcontroller";
++    case EM_VAX:		return "Digital VAX";
++    case EM_CRIS:		return "Axis Communications 32-bit embedded processor";
++    case EM_JAVELIN:		return "Infineon Technologies 32-bit embedded cpu";
++    case EM_FIREPATH:		return "Element 14 64-bit DSP processor";
++    case EM_ZSP:		return "LSI Logic's 16-bit DSP processor";
++      /* 80 */
++    case EM_MMIX:		return "Donald Knuth's educational 64-bit processor";
++    case EM_HUANY:		return "Harvard Universitys's machine-independent object format";
++    case EM_PRISM:		return "Vitesse Prism";
++    case EM_AVR_OLD:
++    case EM_AVR:		return "Atmel AVR 8-bit microcontroller";
++    case EM_CYGNUS_FR30:
++    case EM_FR30:		return "Fujitsu FR30";
++    case EM_CYGNUS_D10V:
++    case EM_D10V:		return "d10v";
++    case EM_CYGNUS_D30V:
++    case EM_D30V:		return "d30v";
++    case EM_CYGNUS_V850:
++    case EM_V850:		return "Renesas V850";
++    case EM_CYGNUS_M32R:
++    case EM_M32R:		return "Renesas M32R (formerly Mitsubishi M32r)";
++    case EM_CYGNUS_MN10300:
++    case EM_MN10300:		return "mn10300";
++      /* 90 */
++    case EM_CYGNUS_MN10200:
++    case EM_MN10200:		return "mn10200";
++    case EM_PJ:			return "picoJava";
++    case EM_OR1K:		return "OpenRISC 1000";
++    case EM_ARC_COMPACT:	return "ARCompact";
++    case EM_XTENSA_OLD:
++    case EM_XTENSA:		return "Tensilica Xtensa Processor";
++    case EM_VIDEOCORE:		return "Alphamosaic VideoCore processor";
++    case EM_TMM_GPP:		return "Thompson Multimedia General Purpose Processor";
++    case EM_NS32K:		return "National Semiconductor 32000 series";
++    case EM_TPC:		return "Tenor Network TPC processor";
++    case EM_SNP1K:	        return "Trebia SNP 1000 processor";
++      /* 100 */
++    case EM_ST200:		return "STMicroelectronics ST200 microcontroller";
++    case EM_IP2K_OLD:
++    case EM_IP2K:		return "Ubicom IP2xxx 8-bit microcontrollers";
++    case EM_MAX:		return "MAX Processor";
++    case EM_CR:			return "National Semiconductor CompactRISC";
++    case EM_F2MC16:		return "Fujitsu F2MC16";
++    case EM_MSP430:		return "Texas Instruments msp430 microcontroller";
++    case EM_BLACKFIN:		return "Analog Devices Blackfin";
++    case EM_SE_C33:		return "S1C33 Family of Seiko Epson processors";
++    case EM_SEP:		return "Sharp embedded microprocessor";
++    case EM_ARCA:		return "Arca RISC microprocessor";
++      /* 110 */
++    case EM_UNICORE:		return "Unicore";
++    case EM_EXCESS:		return "eXcess 16/32/64-bit configurable embedded CPU";
++    case EM_DXP:		return "Icera Semiconductor Inc. Deep Execution Processor";
++    case EM_ALTERA_NIOS2:	return "Altera Nios II";
++    case EM_CRX:		return "National Semiconductor CRX microprocessor";
++    case EM_XGATE:		return "Motorola XGATE embedded processor";
++    case EM_C166:
++    case EM_XC16X:		return "Infineon Technologies xc16x";
++    case EM_M16C:		return "Renesas M16C series microprocessors";
++    case EM_DSPIC30F:		return "Microchip Technology dsPIC30F Digital Signal Controller";
++    case EM_CE:			return "Freescale Communication Engine RISC core";
++      /* 120 */
++    case EM_M32C:	        return "Renesas M32c";
++      /* 130 */
++    case EM_TSK3000:		return "Altium TSK3000 core";
++    case EM_RS08:		return "Freescale RS08 embedded processor";
++    case EM_ECOG2:		return "Cyan Technology eCOG2 microprocessor";
++    case EM_SCORE:		return "SUNPLUS S+Core";
++    case EM_DSP24:		return "New Japan Radio (NJR) 24-bit DSP Processor";
++    case EM_VIDEOCORE3:		return "Broadcom VideoCore III processor";
++    case EM_LATTICEMICO32:	return "Lattice Mico32";
++    case EM_SE_C17:		return "Seiko Epson C17 family";
++      /* 140 */
++    case EM_TI_C6000:		return "Texas Instruments TMS320C6000 DSP family";
++    case EM_TI_C2000:		return "Texas Instruments TMS320C2000 DSP family";
++    case EM_TI_C5500:		return "Texas Instruments TMS320C55x DSP family";
++    case EM_TI_PRU:		return "TI PRU I/O processor";
++      /* 160 */
++    case EM_MMDSP_PLUS:		return "STMicroelectronics 64bit VLIW Data Signal Processor";
++    case EM_CYPRESS_M8C:	return "Cypress M8C microprocessor";
++    case EM_R32C:		return "Renesas R32C series microprocessors";
++    case EM_TRIMEDIA:		return "NXP Semiconductors TriMedia architecture family";
++    case EM_QDSP6:		return "QUALCOMM DSP6 Processor";
++    case EM_8051:		return "Intel 8051 and variants";
++    case EM_STXP7X:		return "STMicroelectronics STxP7x family";
++    case EM_NDS32:		return "Andes Technology compact code size embedded RISC processor family";
++    case EM_ECOG1X:		return "Cyan Technology eCOG1X family";
++    case EM_MAXQ30:		return "Dallas Semiconductor MAXQ30 Core microcontrollers";
++      /* 170 */
++    case EM_XIMO16:		return "New Japan Radio (NJR) 16-bit DSP Processor";
++    case EM_MANIK:		return "M2000 Reconfigurable RISC Microprocessor";
++    case EM_CRAYNV2:		return "Cray Inc. NV2 vector architecture";
++    case EM_RX:			return "Renesas RX";
++    case EM_METAG:		return "Imagination Technologies Meta processor architecture";
++    case EM_MCST_ELBRUS:	return "MCST Elbrus general purpose hardware architecture";
++    case EM_ECOG16:		return "Cyan Technology eCOG16 family";
++    case EM_CR16:
++    case EM_MICROBLAZE:
++    case EM_MICROBLAZE_OLD:	return "Xilinx MicroBlaze";
++    case EM_ETPU:		return "Freescale Extended Time Processing Unit";
++    case EM_SLE9X:		return "Infineon Technologies SLE9X core";
++      /* 180 */
++    case EM_L1OM:		return "Intel L1OM";
++    case EM_K1OM:		return "Intel K1OM";
++    case EM_INTEL182:		return "Intel (reserved)";
++    case EM_AARCH64:		return "AArch64";
++    case EM_ARM184:		return "ARM (reserved)";
++    case EM_AVR32:		return "Atmel Corporation 32-bit microprocessor";
++    case EM_STM8:		return "STMicroeletronics STM8 8-bit microcontroller";
++    case EM_TILE64:		return "Tilera TILE64 multicore architecture family";
++    case EM_TILEPRO:		return "Tilera TILEPro multicore architecture family";
++      /* 190 */
++    case EM_CUDA:		return "NVIDIA CUDA architecture";
++    case EM_TILEGX:		return "Tilera TILE-Gx multicore architecture family";
++    case EM_CLOUDSHIELD:	return "CloudShield architecture family";
++    case EM_COREA_1ST:		return "KIPO-KAIST Core-A 1st generation processor family";
++    case EM_COREA_2ND:		return "KIPO-KAIST Core-A 2nd generation processor family";
++    case EM_ARC_COMPACT2:	return "ARCv2";
++    case EM_OPEN8:		return "Open8 8-bit RISC soft processor core";
++    case EM_RL78:		return "Renesas RL78";
++    case EM_VIDEOCORE5:		return "Broadcom VideoCore V processor";
++    case EM_78K0R:		return "Renesas 78K0R";
++      /* 200 */
++    case EM_56800EX:		return "Freescale 56800EX Digital Signal Controller (DSC)";
++    case EM_BA1:		return "Beyond BA1 CPU architecture";
++    case EM_BA2:		return "Beyond BA2 CPU architecture";
++    case EM_XCORE:		return "XMOS xCORE processor family";
++    case EM_MCHP_PIC:		return "Microchip 8-bit PIC(r) family";
++    case EM_INTELGT:		return "Intel Graphics Technology";
++      /* 210 */
++    case EM_KM32:		return "KM211 KM32 32-bit processor";
++    case EM_KMX32:		return "KM211 KMX32 32-bit processor";
++    case EM_KMX16:		return "KM211 KMX16 16-bit processor";
++    case EM_KMX8:		return "KM211 KMX8 8-bit processor";
++    case EM_KVARC:		return "KM211 KVARC processor";
++    case EM_CDP:		return "Paneve CDP architecture family";
++    case EM_COGE:		return "Cognitive Smart Memory Processor";
++    case EM_COOL:		return "Bluechip Systems CoolEngine";
++    case EM_NORC:		return "Nanoradio Optimized RISC";
++    case EM_CSR_KALIMBA:	return "CSR Kalimba architecture family";
++      /* 220 */
++    case EM_Z80:		return "Zilog Z80";
++    case EM_VISIUM:		return "CDS VISIUMcore processor";
++    case EM_FT32:               return "FTDI Chip FT32";
++    case EM_MOXIE:              return "Moxie";
++    case EM_AMDGPU: 	 	return "AMD GPU";
++      /* 230 (all reserved) */
++      /* 240 */
++    case EM_RISCV: 	 	return "RISC-V";
++    case EM_LANAI:		return "Lanai 32-bit processor";
++    case EM_CEVA:		return "CEVA Processor Architecture Family";
++    case EM_CEVA_X2:		return "CEVA X2 Processor Family";
++    case EM_BPF:		return "Linux BPF";
++    case EM_GRAPHCORE_IPU:	return "Graphcore Intelligent Processing Unit";
++    case EM_IMG1:		return "Imagination Technologies";
++      /* 250 */
++    case EM_NFP:		return "Netronome Flow Processor";
++    case EM_VE:			return "NEC Vector Engine";
++    case EM_CSKY:		return "C-SKY";
++    case EM_ARC_COMPACT3_64:	return "Synopsys ARCv2.3 64-bit";
++    case EM_MCS6502:		return "MOS Technology MCS 6502 processor";
++    case EM_ARC_COMPACT3:	return "Synopsys ARCv2.3 32-bit";
++    case EM_KVX:		return "Kalray VLIW core of the MPPA processor family";
++    case EM_65816:		return "WDC 65816/65C816";
++    case EM_LOONGARCH:		return "LoongArch";
++    case EM_KF32:		return "ChipON KungFu32";
++
++      /* Large numbers...  */
++    case EM_MT:                 return "Morpho Techologies MT processor";
++    case EM_ALPHA:		return "Alpha";
++    case EM_WEBASSEMBLY:	return "Web Assembly";
++    case EM_DLX:		return "OpenDLX";
++    case EM_XSTORMY16:		return "Sanyo XStormy16 CPU core";
++    case EM_IQ2000:       	return "Vitesse IQ2000";
++    case EM_M32C_OLD:
++    case EM_NIOS32:		return "Altera Nios";
++    case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
++    case EM_ADAPTEVA_EPIPHANY:	return "Adapteva EPIPHANY";
++    case EM_CYGNUS_FRV:		return "Fujitsu FR-V";
++    case EM_S12Z:               return "Freescale S12Z";
++
++    default:
++      snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
++      return buff;
++    }
++}
++
++static void
++decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
++{
++  /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2.  Some
++     other compilers don't specify an architecture type in the e_flags, and
++     instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
++     architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
++     architectures.
++
++     Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
++     but also sets a specific architecture type in the e_flags field.
++
++     However, when decoding the flags we don't worry if we see an
++     unexpected pairing, for example EM_ARC_COMPACT machine type, with
++     ARCEM architecture type.  */
++
++  switch (e_flags & EF_ARC_MACH_MSK)
++    {
++      /* We only expect these to occur for EM_ARC_COMPACT2.  */
++    case EF_ARC_CPU_ARCV2EM:
++      strcat (buf, ", ARC EM");
++      break;
++    case EF_ARC_CPU_ARCV2HS:
++      strcat (buf, ", ARC HS");
++      break;
++
++      /* We only expect these to occur for EM_ARC_COMPACT.  */
++    case E_ARC_MACH_ARC600:
++      strcat (buf, ", ARC600");
++      break;
++    case E_ARC_MACH_ARC601:
++      strcat (buf, ", ARC601");
++      break;
++    case E_ARC_MACH_ARC700:
++      strcat (buf, ", ARC700");
++      break;
++
++      /* The only times we should end up here are (a) A corrupt ELF, (b) A
++         new ELF with new architecture being read by an old version of
++         readelf, or (c) An ELF built with non-GNU compiler that does not
++         set the architecture in the e_flags.  */
++    default:
++      if (e_machine == EM_ARC_COMPACT)
++        strcat (buf, ", Unknown ARCompact");
++      else
++        strcat (buf, ", Unknown ARC");
++      break;
++    }
++
++  switch (e_flags & EF_ARC_OSABI_MSK)
++    {
++    case E_ARC_OSABI_ORIG:
++      strcat (buf, ", (ABI:legacy)");
++      break;
++    case E_ARC_OSABI_V2:
++      strcat (buf, ", (ABI:v2)");
++      break;
++      /* Only upstream 3.9+ kernels will support ARCv2 ISA.  */
++    case E_ARC_OSABI_V3:
++      strcat (buf, ", v3 no-legacy-syscalls ABI");
++      break;
++    case E_ARC_OSABI_V4:
++      strcat (buf, ", v4 ABI");
++      break;
++    default:
++      strcat (buf, ", unrecognised ARC OSABI flag");
++      break;
++    }
++}
++
++static void
++decode_ARM_machine_flags (unsigned e_flags, char buf[])
++{
++  unsigned eabi;
++  bool unknown = false;
++
++  eabi = EF_ARM_EABI_VERSION (e_flags);
++  e_flags &= ~ EF_ARM_EABIMASK;
++
++  /* Handle "generic" ARM flags.  */
++  if (e_flags & EF_ARM_RELEXEC)
++    {
++      strcat (buf, ", relocatable executable");
++      e_flags &= ~ EF_ARM_RELEXEC;
++    }
++
++  if (e_flags & EF_ARM_PIC)
++    {
++      strcat (buf, ", position independent");
++      e_flags &= ~ EF_ARM_PIC;
++    }
++
++  /* Now handle EABI specific flags.  */
++  switch (eabi)
++    {
++    default:
++      strcat (buf, ", <unrecognized EABI>");
++      if (e_flags)
++	unknown = true;
++      break;
++
++    case EF_ARM_EABI_VER1:
++      strcat (buf, ", Version1 EABI");
++      while (e_flags)
++	{
++	  unsigned flag;
++
++	  /* Process flags one bit at a time.  */
++	  flag = e_flags & - e_flags;
++	  e_flags &= ~ flag;
++
++	  switch (flag)
++	    {
++	    case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
++	      strcat (buf, ", sorted symbol tables");
++	      break;
++
++	    default:
++	      unknown = true;
++	      break;
++	    }
++	}
++      break;
++
++    case EF_ARM_EABI_VER2:
++      strcat (buf, ", Version2 EABI");
++      while (e_flags)
++	{
++	  unsigned flag;
++
++	  /* Process flags one bit at a time.  */
++	  flag = e_flags & - e_flags;
++	  e_flags &= ~ flag;
++
++	  switch (flag)
++	    {
++	    case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
++	      strcat (buf, ", sorted symbol tables");
++	      break;
++
++	    case EF_ARM_DYNSYMSUSESEGIDX:
++	      strcat (buf, ", dynamic symbols use segment index");
++	      break;
++
++	    case EF_ARM_MAPSYMSFIRST:
++	      strcat (buf, ", mapping symbols precede others");
++	      break;
++
++	    default:
++	      unknown = true;
++	      break;
++	    }
++	}
++      break;
++
++    case EF_ARM_EABI_VER3:
++      strcat (buf, ", Version3 EABI");
++      break;
++
++    case EF_ARM_EABI_VER4:
++      strcat (buf, ", Version4 EABI");
++      while (e_flags)
++	{
++	  unsigned flag;
++
++	  /* Process flags one bit at a time.  */
++	  flag = e_flags & - e_flags;
++	  e_flags &= ~ flag;
++
++	  switch (flag)
++	    {
++	    case EF_ARM_BE8:
++	      strcat (buf, ", BE8");
++	      break;
++
++	    case EF_ARM_LE8:
++	      strcat (buf, ", LE8");
++	      break;
++
++	    default:
++	      unknown = true;
++	      break;
++	    }
++	}
++      break;
++
++    case EF_ARM_EABI_VER5:
++      strcat (buf, ", Version5 EABI");
++      while (e_flags)
++	{
++	  unsigned flag;
++
++	  /* Process flags one bit at a time.  */
++	  flag = e_flags & - e_flags;
++	  e_flags &= ~ flag;
++
++	  switch (flag)
++	    {
++	    case EF_ARM_BE8:
++	      strcat (buf, ", BE8");
++	      break;
++
++	    case EF_ARM_LE8:
++	      strcat (buf, ", LE8");
++	      break;
++
++	    case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
++	      strcat (buf, ", soft-float ABI");
++	      break;
++
++	    case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
++	      strcat (buf, ", hard-float ABI");
++	      break;
++
++	    default:
++	      unknown = true;
++	      break;
++	    }
++	}
++      break;
++
++    case EF_ARM_EABI_UNKNOWN:
++      strcat (buf, ", GNU EABI");
++      while (e_flags)
++	{
++	  unsigned flag;
++
++	  /* Process flags one bit at a time.  */
++	  flag = e_flags & - e_flags;
++	  e_flags &= ~ flag;
++
++	  switch (flag)
++	    {
++	    case EF_ARM_INTERWORK:
++	      strcat (buf, ", interworking enabled");
++	      break;
++
++	    case EF_ARM_APCS_26:
++	      strcat (buf, ", uses APCS/26");
++	      break;
++
++	    case EF_ARM_APCS_FLOAT:
++	      strcat (buf, ", uses APCS/float");
++	      break;
++
++	    case EF_ARM_PIC:
++	      strcat (buf, ", position independent");
++	      break;
++
++	    case EF_ARM_ALIGN8:
++	      strcat (buf, ", 8 bit structure alignment");
++	      break;
++
++	    case EF_ARM_NEW_ABI:
++	      strcat (buf, ", uses new ABI");
++	      break;
++
++	    case EF_ARM_OLD_ABI:
++	      strcat (buf, ", uses old ABI");
++	      break;
++
++	    case EF_ARM_SOFT_FLOAT:
++	      strcat (buf, ", software FP");
++	      break;
++
++	    case EF_ARM_VFP_FLOAT:
++	      strcat (buf, ", VFP");
++	      break;
++
++	    case EF_ARM_MAVERICK_FLOAT:
++	      strcat (buf, ", Maverick FP");
++	      break;
++
++	    default:
++	      unknown = true;
++	      break;
++	    }
++	}
++    }
++
++  if (unknown)
++    strcat (buf,_(", <unknown>"));
++}
++
++static void
++decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
++{
++  --size; /* Leave space for null terminator.  */
++
++  switch (e_flags & EF_AVR_MACH)
++    {
++    case E_AVR_MACH_AVR1:
++      strncat (buf, ", avr:1", size);
++      break;
++    case E_AVR_MACH_AVR2:
++      strncat (buf, ", avr:2", size);
++      break;
++    case E_AVR_MACH_AVR25:
++      strncat (buf, ", avr:25", size);
++      break;
++    case E_AVR_MACH_AVR3:
++      strncat (buf, ", avr:3", size);
++      break;
++    case E_AVR_MACH_AVR31:
++      strncat (buf, ", avr:31", size);
++      break;
++    case E_AVR_MACH_AVR35:
++      strncat (buf, ", avr:35", size);
++      break;
++    case E_AVR_MACH_AVR4:
++      strncat (buf, ", avr:4", size);
++      break;
++    case E_AVR_MACH_AVR5:
++      strncat (buf, ", avr:5", size);
++      break;
++    case E_AVR_MACH_AVR51:
++      strncat (buf, ", avr:51", size);
++      break;
++    case E_AVR_MACH_AVR6:
++      strncat (buf, ", avr:6", size);
++      break;
++    case E_AVR_MACH_AVRTINY:
++      strncat (buf, ", avr:100", size);
++      break;
++    case E_AVR_MACH_XMEGA1:
++      strncat (buf, ", avr:101", size);
++      break;
++    case E_AVR_MACH_XMEGA2:
++      strncat (buf, ", avr:102", size);
++      break;
++    case E_AVR_MACH_XMEGA3:
++      strncat (buf, ", avr:103", size);
++      break;
++    case E_AVR_MACH_XMEGA4:
++      strncat (buf, ", avr:104", size);
++      break;
++    case E_AVR_MACH_XMEGA5:
++      strncat (buf, ", avr:105", size);
++      break;
++    case E_AVR_MACH_XMEGA6:
++      strncat (buf, ", avr:106", size);
++      break;
++    case E_AVR_MACH_XMEGA7:
++      strncat (buf, ", avr:107", size);
++      break;
++    default:
++      strncat (buf, ", avr:<unknown>", size);
++      break;
++    }
++
++  size -= strlen (buf);
++  if (e_flags & EF_AVR_LINKRELAX_PREPARED)
++    strncat (buf, ", link-relax", size);
++}
++
++static void
++decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
++{
++  unsigned abi;
++  unsigned arch;
++  unsigned config;
++  unsigned version;
++  bool has_fpu = false;
++  unsigned int r = 0;
++
++  static const char *ABI_STRINGS[] =
++  {
++    "ABI v0", /* use r5 as return register; only used in N1213HC */
++    "ABI v1", /* use r0 as return register */
++    "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
++    "ABI v2fp", /* for FPU */
++    "AABI",
++    "ABI2 FP+"
++  };
++  static const char *VER_STRINGS[] =
++  {
++    "Andes ELF V1.3 or older",
++    "Andes ELF V1.3.1",
++    "Andes ELF V1.4"
++  };
++  static const char *ARCH_STRINGS[] =
++  {
++    "",
++    "Andes Star v1.0",
++    "Andes Star v2.0",
++    "Andes Star v3.0",
++    "Andes Star v3.0m"
++  };
++
++  abi = EF_NDS_ABI & e_flags;
++  arch = EF_NDS_ARCH & e_flags;
++  config = EF_NDS_INST & e_flags;
++  version = EF_NDS32_ELF_VERSION & e_flags;
++
++  memset (buf, 0, size);
++
++  switch (abi)
++    {
++    case E_NDS_ABI_V0:
++    case E_NDS_ABI_V1:
++    case E_NDS_ABI_V2:
++    case E_NDS_ABI_V2FP:
++    case E_NDS_ABI_AABI:
++    case E_NDS_ABI_V2FP_PLUS:
++      /* In case there are holes in the array.  */
++      r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
++      break;
++
++    default:
++      r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
++      break;
++    }
++
++  switch (version)
++    {
++    case E_NDS32_ELF_VER_1_2:
++    case E_NDS32_ELF_VER_1_3:
++    case E_NDS32_ELF_VER_1_4:
++      r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
++      break;
++
++    default:
++      r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
++      break;
++    }
++
++  if (E_NDS_ABI_V0 == abi)
++    {
++      /* OLD ABI; only used in N1213HC, has performance extension 1.  */
++      r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
++      if (arch == E_NDS_ARCH_STAR_V1_0)
++	r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
++      return;
++    }
++
++  switch (arch)
++    {
++    case E_NDS_ARCH_STAR_V1_0:
++    case E_NDS_ARCH_STAR_V2_0:
++    case E_NDS_ARCH_STAR_V3_0:
++    case E_NDS_ARCH_STAR_V3_M:
++      r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
++      break;
++
++    default:
++      r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
++      /* ARCH version determines how the e_flags are interpreted.
++	 If it is unknown, we cannot proceed.  */
++      return;
++    }
++
++  /* Newer ABI; Now handle architecture specific flags.  */
++  if (arch == E_NDS_ARCH_STAR_V1_0)
++    {
++      if (config & E_NDS32_HAS_MFUSR_PC_INST)
++	r += snprintf (buf + r, size -r, ", MFUSR_PC");
++
++      if (!(config & E_NDS32_HAS_NO_MAC_INST))
++	r += snprintf (buf + r, size -r, ", MAC");
++
++      if (config & E_NDS32_HAS_DIV_INST)
++	r += snprintf (buf + r, size -r, ", DIV");
++
++      if (config & E_NDS32_HAS_16BIT_INST)
++	r += snprintf (buf + r, size -r, ", 16b");
++    }
++  else
++    {
++      if (config & E_NDS32_HAS_MFUSR_PC_INST)
++	{
++	  if (version <= E_NDS32_ELF_VER_1_3)
++	    r += snprintf (buf + r, size -r, ", [B8]");
++	  else
++	    r += snprintf (buf + r, size -r, ", EX9");
++	}
++
++      if (config & E_NDS32_HAS_MAC_DX_INST)
++	r += snprintf (buf + r, size -r, ", MAC_DX");
++
++      if (config & E_NDS32_HAS_DIV_DX_INST)
++	r += snprintf (buf + r, size -r, ", DIV_DX");
++
++      if (config & E_NDS32_HAS_16BIT_INST)
++	{
++	  if (version <= E_NDS32_ELF_VER_1_3)
++	    r += snprintf (buf + r, size -r, ", 16b");
++	  else
++	    r += snprintf (buf + r, size -r, ", IFC");
++	}
++    }
++
++  if (config & E_NDS32_HAS_EXT_INST)
++    r += snprintf (buf + r, size -r, ", PERF1");
++
++  if (config & E_NDS32_HAS_EXT2_INST)
++    r += snprintf (buf + r, size -r, ", PERF2");
++
++  if (config & E_NDS32_HAS_FPU_INST)
++    {
++      has_fpu = true;
++      r += snprintf (buf + r, size -r, ", FPU_SP");
++    }
++
++  if (config & E_NDS32_HAS_FPU_DP_INST)
++    {
++      has_fpu = true;
++      r += snprintf (buf + r, size -r, ", FPU_DP");
++    }
++
++  if (config & E_NDS32_HAS_FPU_MAC_INST)
++    {
++      has_fpu = true;
++      r += snprintf (buf + r, size -r, ", FPU_MAC");
++    }
++
++  if (has_fpu)
++    {
++      switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
++	{
++	case E_NDS32_FPU_REG_8SP_4DP:
++	  r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
++	  break;
++	case E_NDS32_FPU_REG_16SP_8DP:
++	  r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
++	  break;
++	case E_NDS32_FPU_REG_32SP_16DP:
++	  r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
++	  break;
++	case E_NDS32_FPU_REG_32SP_32DP:
++	  r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
++	  break;
++	}
++    }
++
++  if (config & E_NDS32_HAS_AUDIO_INST)
++    r += snprintf (buf + r, size -r, ", AUDIO");
++
++  if (config & E_NDS32_HAS_STRING_INST)
++    r += snprintf (buf + r, size -r, ", STR");
++
++  if (config & E_NDS32_HAS_REDUCED_REGS)
++    r += snprintf (buf + r, size -r, ", 16REG");
++
++  if (config & E_NDS32_HAS_VIDEO_INST)
++    {
++      if (version <= E_NDS32_ELF_VER_1_3)
++	r += snprintf (buf + r, size -r, ", VIDEO");
++      else
++	r += snprintf (buf + r, size -r, ", SATURATION");
++    }
++
++  if (config & E_NDS32_HAS_ENCRIPT_INST)
++    r += snprintf (buf + r, size -r, ", ENCRP");
++
++  if (config & E_NDS32_HAS_L2C_INST)
++    r += snprintf (buf + r, size -r, ", L2C");
++}
++
++static char *
++get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine)
++{
++  static char buf[1024];
++
++  buf[0] = '\0';
++
++  if (e_flags)
++    {
++      switch (e_machine)
++	{
++	default:
++	  break;
++
++	case EM_ARC_COMPACT2:
++	case EM_ARC_COMPACT:
++          decode_ARC_machine_flags (e_flags, e_machine, buf);
++          break;
++
++	case EM_ARM:
++	  decode_ARM_machine_flags (e_flags, buf);
++	  break;
++
++        case EM_AVR:
++          decode_AVR_machine_flags (e_flags, buf, sizeof buf);
++          break;
++
++	case EM_BLACKFIN:
++	  if (e_flags & EF_BFIN_PIC)
++	    strcat (buf, ", PIC");
++
++	  if (e_flags & EF_BFIN_FDPIC)
++	    strcat (buf, ", FDPIC");
++
++	  if (e_flags & EF_BFIN_CODE_IN_L1)
++	    strcat (buf, ", code in L1");
++
++	  if (e_flags & EF_BFIN_DATA_IN_L1)
++	    strcat (buf, ", data in L1");
++
++	  break;
++
++	case EM_CYGNUS_FRV:
++	  switch (e_flags & EF_FRV_CPU_MASK)
++	    {
++	    case EF_FRV_CPU_GENERIC:
++	      break;
++
++	    default:
++	      strcat (buf, ", fr???");
++	      break;
++
++	    case EF_FRV_CPU_FR300:
++	      strcat (buf, ", fr300");
++	      break;
++
++	    case EF_FRV_CPU_FR400:
++	      strcat (buf, ", fr400");
++	      break;
++	    case EF_FRV_CPU_FR405:
++	      strcat (buf, ", fr405");
++	      break;
++
++	    case EF_FRV_CPU_FR450:
++	      strcat (buf, ", fr450");
++	      break;
++
++	    case EF_FRV_CPU_FR500:
++	      strcat (buf, ", fr500");
++	      break;
++	    case EF_FRV_CPU_FR550:
++	      strcat (buf, ", fr550");
++	      break;
++
++	    case EF_FRV_CPU_SIMPLE:
++	      strcat (buf, ", simple");
++	      break;
++	    case EF_FRV_CPU_TOMCAT:
++	      strcat (buf, ", tomcat");
++	      break;
++	    }
++	  break;
++
++	case EM_68K:
++	  if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
++	    strcat (buf, ", m68000");
++	  else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
++	    strcat (buf, ", cpu32");
++	  else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
++	    strcat (buf, ", fido_a");
++	  else
++	    {
++	      char const * isa = _("unknown");
++	      char const * mac = _("unknown mac");
++	      char const * additional = NULL;
++
++	      switch (e_flags & EF_M68K_CF_ISA_MASK)
++		{
++		case EF_M68K_CF_ISA_A_NODIV:
++		  isa = "A";
++		  additional = ", nodiv";
++		  break;
++		case EF_M68K_CF_ISA_A:
++		  isa = "A";
++		  break;
++		case EF_M68K_CF_ISA_A_PLUS:
++		  isa = "A+";
++		  break;
++		case EF_M68K_CF_ISA_B_NOUSP:
++		  isa = "B";
++		  additional = ", nousp";
++		  break;
++		case EF_M68K_CF_ISA_B:
++		  isa = "B";
++		  break;
++		case EF_M68K_CF_ISA_C:
++		  isa = "C";
++		  break;
++		case EF_M68K_CF_ISA_C_NODIV:
++		  isa = "C";
++		  additional = ", nodiv";
++		  break;
++		}
++	      strcat (buf, ", cf, isa ");
++	      strcat (buf, isa);
++	      if (additional)
++		strcat (buf, additional);
++	      if (e_flags & EF_M68K_CF_FLOAT)
++		strcat (buf, ", float");
++	      switch (e_flags & EF_M68K_CF_MAC_MASK)
++		{
++		case 0:
++		  mac = NULL;
++		  break;
++		case EF_M68K_CF_MAC:
++		  mac = "mac";
++		  break;
++		case EF_M68K_CF_EMAC:
++		  mac = "emac";
++		  break;
++		case EF_M68K_CF_EMAC_B:
++		  mac = "emac_b";
++		  break;
++		}
++	      if (mac)
++		{
++		  strcat (buf, ", ");
++		  strcat (buf, mac);
++		}
++	    }
++	  break;
++
++	case EM_CYGNUS_MEP:
++	  switch (e_flags & EF_MEP_CPU_MASK)
++	    {
++	    case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
++	    case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
++	    case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
++	    case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
++	    case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
++	    case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
++	    default: strcat (buf, _(", <unknown MeP cpu type>")); break;
++	    }
++
++	  switch (e_flags & EF_MEP_COP_MASK)
++	    {
++	    case EF_MEP_COP_NONE: break;
++	    case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
++	    case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
++	    case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
++	    case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
++	    default: strcat (buf, _("<unknown MeP copro type>")); break;
++	    }
++
++	  if (e_flags & EF_MEP_LIBRARY)
++	    strcat (buf, ", Built for Library");
++
++	  if (e_flags & EF_MEP_INDEX_MASK)
++	    sprintf (buf + strlen (buf), ", Configuration Index: %#x",
++		     e_flags & EF_MEP_INDEX_MASK);
++
++	  if (e_flags & ~ EF_MEP_ALL_FLAGS)
++	    sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
++		     e_flags & ~ EF_MEP_ALL_FLAGS);
++	  break;
++
++	case EM_PPC:
++	  if (e_flags & EF_PPC_EMB)
++	    strcat (buf, ", emb");
++
++	  if (e_flags & EF_PPC_RELOCATABLE)
++	    strcat (buf, _(", relocatable"));
++
++	  if (e_flags & EF_PPC_RELOCATABLE_LIB)
++	    strcat (buf, _(", relocatable-lib"));
++	  break;
++
++	case EM_PPC64:
++	  if (e_flags & EF_PPC64_ABI)
++	    {
++	      char abi[] = ", abiv0";
++
++	      abi[6] += e_flags & EF_PPC64_ABI;
++	      strcat (buf, abi);
++	    }
++	  break;
++
++	case EM_V800:
++	  if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
++	    strcat (buf, ", RH850 ABI");
++
++	  if (e_flags & EF_V800_850E3)
++	    strcat (buf, ", V3 architecture");
++
++	  if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
++	    strcat (buf, ", FPU not used");
++
++	  if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
++	    strcat (buf, ", regmode: COMMON");
++
++	  if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
++	    strcat (buf, ", r4 not used");
++
++	  if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
++	    strcat (buf, ", r30 not used");
++
++	  if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
++	    strcat (buf, ", r5 not used");
++
++	  if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
++	    strcat (buf, ", r2 not used");
++
++	  for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
++	    {
++	      switch (e_flags & - e_flags)
++		{
++		case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
++		case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
++		case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
++		case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
++		case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
++		case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
++		case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
++		case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
++		case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
++		case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
++		case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
++		case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
++		default: break;
++		}
++	    }
++	  break;
++
++	case EM_V850:
++	case EM_CYGNUS_V850:
++	  switch (e_flags & EF_V850_ARCH)
++	    {
++	    case E_V850E3V5_ARCH:
++	      strcat (buf, ", v850e3v5");
++	      break;
++	    case E_V850E2V3_ARCH:
++	      strcat (buf, ", v850e2v3");
++	      break;
++	    case E_V850E2_ARCH:
++	      strcat (buf, ", v850e2");
++	      break;
++            case E_V850E1_ARCH:
++              strcat (buf, ", v850e1");
++	      break;
++	    case E_V850E_ARCH:
++	      strcat (buf, ", v850e");
++	      break;
++	    case E_V850_ARCH:
++	      strcat (buf, ", v850");
++	      break;
++	    default:
++	      strcat (buf, _(", unknown v850 architecture variant"));
++	      break;
++	    }
++	  break;
++
++	case EM_M32R:
++	case EM_CYGNUS_M32R:
++	  if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
++	    strcat (buf, ", m32r");
++	  break;
++
++	case EM_MIPS:
++	case EM_MIPS_RS3_LE:
++	  if (e_flags & EF_MIPS_NOREORDER)
++	    strcat (buf, ", noreorder");
++
++	  if (e_flags & EF_MIPS_PIC)
++	    strcat (buf, ", pic");
++
++	  if (e_flags & EF_MIPS_CPIC)
++	    strcat (buf, ", cpic");
++
++	  if (e_flags & EF_MIPS_UCODE)
++	    strcat (buf, ", ugen_reserved");
++
++	  if (e_flags & EF_MIPS_ABI2)
++	    strcat (buf, ", abi2");
++
++	  if (e_flags & EF_MIPS_OPTIONS_FIRST)
++	    strcat (buf, ", odk first");
++
++	  if (e_flags & EF_MIPS_32BITMODE)
++	    strcat (buf, ", 32bitmode");
++
++	  if (e_flags & EF_MIPS_NAN2008)
++	    strcat (buf, ", nan2008");
++
++	  if (e_flags & EF_MIPS_FP64)
++	    strcat (buf, ", fp64");
++
++	  switch ((e_flags & EF_MIPS_MACH))
++	    {
++	    case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
++	    case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
++	    case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
++	    case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
++	    case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
++	    case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
++	    case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
++	    case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
++	    case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break;
++	    case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
++	    case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
++  	    case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
++  	    case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
++	    case E_MIPS_MACH_GS464: strcat (buf, ", gs464"); break;
++	    case E_MIPS_MACH_GS464E: strcat (buf, ", gs464e"); break;
++	    case E_MIPS_MACH_GS264E: strcat (buf, ", gs264e"); break;
++	    case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
++	    case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
++	    case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
++	    case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
++	    case E_MIPS_MACH_IAMR2:  strcat (buf, ", interaptiv-mr2"); break;
++	    case 0:
++	    /* We simply ignore the field in this case to avoid confusion:
++	       MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
++	       extension.  */
++	      break;
++	    default: strcat (buf, _(", unknown CPU")); break;
++	    }
++
++	  switch ((e_flags & EF_MIPS_ABI))
++	    {
++	    case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
++	    case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
++	    case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
++	    case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
++	    case 0:
++	    /* We simply ignore the field in this case to avoid confusion:
++	       MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
++	       This means it is likely to be an o32 file, but not for
++	       sure.  */
++	      break;
++	    default: strcat (buf, _(", unknown ABI")); break;
++	    }
++
++	  if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
++	    strcat (buf, ", mdmx");
++
++	  if (e_flags & EF_MIPS_ARCH_ASE_M16)
++	    strcat (buf, ", mips16");
++
++	  if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
++	    strcat (buf, ", micromips");
++
++	  switch ((e_flags & EF_MIPS_ARCH))
++	    {
++	    case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
++	    case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
++	    case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
++	    case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
++	    case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
++	    case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
++	    case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
++	    case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
++	    case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
++	    case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
++	    case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
++	    default: strcat (buf, _(", unknown ISA")); break;
++	    }
++	  break;
++
++	case EM_NDS32:
++	  decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
++	  break;
++
++	case EM_NFP:
++	  switch (EF_NFP_MACH (e_flags))
++	    {
++	    case E_NFP_MACH_3200:
++	      strcat (buf, ", NFP-32xx");
++	      break;
++	    case E_NFP_MACH_6000:
++	      strcat (buf, ", NFP-6xxx");
++	      break;
++	    }
++	  break;
++
++	case EM_RISCV:
++	  if (e_flags & EF_RISCV_RVC)
++	    strcat (buf, ", RVC");
++
++	  if (e_flags & EF_RISCV_RVE)
++	    strcat (buf, ", RVE");
++
++	  switch (e_flags & EF_RISCV_FLOAT_ABI)
++	    {
++	    case EF_RISCV_FLOAT_ABI_SOFT:
++	      strcat (buf, ", soft-float ABI");
++	      break;
++
++	    case EF_RISCV_FLOAT_ABI_SINGLE:
++	      strcat (buf, ", single-float ABI");
++	      break;
++
++	    case EF_RISCV_FLOAT_ABI_DOUBLE:
++	      strcat (buf, ", double-float ABI");
++	      break;
++
++	    case EF_RISCV_FLOAT_ABI_QUAD:
++	      strcat (buf, ", quad-float ABI");
++	      break;
++	    }
++	  break;
++
++	case EM_SH:
++	  switch ((e_flags & EF_SH_MACH_MASK))
++	    {
++	    case EF_SH1: strcat (buf, ", sh1"); break;
++	    case EF_SH2: strcat (buf, ", sh2"); break;
++	    case EF_SH3: strcat (buf, ", sh3"); break;
++	    case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
++	    case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
++	    case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
++	    case EF_SH3E: strcat (buf, ", sh3e"); break;
++	    case EF_SH4: strcat (buf, ", sh4"); break;
++	    case EF_SH5: strcat (buf, ", sh5"); break;
++	    case EF_SH2E: strcat (buf, ", sh2e"); break;
++	    case EF_SH4A: strcat (buf, ", sh4a"); break;
++	    case EF_SH2A: strcat (buf, ", sh2a"); break;
++	    case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
++	    case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
++	    case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
++	    case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
++	    case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
++	    case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
++	    case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
++	    case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
++	    case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
++	    default: strcat (buf, _(", unknown ISA")); break;
++	    }
++
++	  if (e_flags & EF_SH_PIC)
++	    strcat (buf, ", pic");
++
++	  if (e_flags & EF_SH_FDPIC)
++	    strcat (buf, ", fdpic");
++	  break;
++
++        case EM_OR1K:
++          if (e_flags & EF_OR1K_NODELAY)
++            strcat (buf, ", no delay");
++          break;
++
++	case EM_SPARCV9:
++	  if (e_flags & EF_SPARC_32PLUS)
++	    strcat (buf, ", v8+");
++
++	  if (e_flags & EF_SPARC_SUN_US1)
++	    strcat (buf, ", ultrasparcI");
++
++	  if (e_flags & EF_SPARC_SUN_US3)
++	    strcat (buf, ", ultrasparcIII");
++
++	  if (e_flags & EF_SPARC_HAL_R1)
++	    strcat (buf, ", halr1");
++
++	  if (e_flags & EF_SPARC_LEDATA)
++	    strcat (buf, ", ledata");
++
++	  if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
++	    strcat (buf, ", tso");
++
++	  if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
++	    strcat (buf, ", pso");
++
++	  if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
++	    strcat (buf, ", rmo");
++	  break;
++
++	case EM_PARISC:
++	  switch (e_flags & EF_PARISC_ARCH)
++	    {
++	    case EFA_PARISC_1_0:
++	      strcpy (buf, ", PA-RISC 1.0");
++	      break;
++	    case EFA_PARISC_1_1:
++	      strcpy (buf, ", PA-RISC 1.1");
++	      break;
++	    case EFA_PARISC_2_0:
++	      strcpy (buf, ", PA-RISC 2.0");
++	      break;
++	    default:
++	      break;
++	    }
++	  if (e_flags & EF_PARISC_TRAPNIL)
++	    strcat (buf, ", trapnil");
++	  if (e_flags & EF_PARISC_EXT)
++	    strcat (buf, ", ext");
++	  if (e_flags & EF_PARISC_LSB)
++	    strcat (buf, ", lsb");
++	  if (e_flags & EF_PARISC_WIDE)
++	    strcat (buf, ", wide");
++	  if (e_flags & EF_PARISC_NO_KABP)
++	    strcat (buf, ", no kabp");
++	  if (e_flags & EF_PARISC_LAZYSWAP)
++	    strcat (buf, ", lazyswap");
++	  break;
++
++	case EM_PJ:
++	case EM_PJ_OLD:
++	  if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
++	    strcat (buf, ", new calling convention");
++
++	  if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
++	    strcat (buf, ", gnu calling convention");
++	  break;
++
++	case EM_IA_64:
++	  if ((e_flags & EF_IA_64_ABI64))
++	    strcat (buf, ", 64-bit");
++	  else
++	    strcat (buf, ", 32-bit");
++	  if ((e_flags & EF_IA_64_REDUCEDFP))
++	    strcat (buf, ", reduced fp model");
++	  if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
++	    strcat (buf, ", no function descriptors, constant gp");
++	  else if ((e_flags & EF_IA_64_CONS_GP))
++	    strcat (buf, ", constant gp");
++	  if ((e_flags & EF_IA_64_ABSOLUTE))
++	    strcat (buf, ", absolute");
++          if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
++            {
++              if ((e_flags & EF_IA_64_VMS_LINKAGES))
++                strcat (buf, ", vms_linkages");
++              switch ((e_flags & EF_IA_64_VMS_COMCOD))
++                {
++                case EF_IA_64_VMS_COMCOD_SUCCESS:
++                  break;
++                case EF_IA_64_VMS_COMCOD_WARNING:
++                  strcat (buf, ", warning");
++                  break;
++                case EF_IA_64_VMS_COMCOD_ERROR:
++                  strcat (buf, ", error");
++                  break;
++                case EF_IA_64_VMS_COMCOD_ABORT:
++                  strcat (buf, ", abort");
++                  break;
++                default:
++		  warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
++			e_flags & EF_IA_64_VMS_COMCOD);
++		  strcat (buf, ", <unknown>");
++                }
++            }
++	  break;
++
++	case EM_VAX:
++	  if ((e_flags & EF_VAX_NONPIC))
++	    strcat (buf, ", non-PIC");
++	  if ((e_flags & EF_VAX_DFLOAT))
++	    strcat (buf, ", D-Float");
++	  if ((e_flags & EF_VAX_GFLOAT))
++	    strcat (buf, ", G-Float");
++	  break;
++
++        case EM_VISIUM:
++	  if (e_flags & EF_VISIUM_ARCH_MCM)
++	    strcat (buf, ", mcm");
++	  else if (e_flags & EF_VISIUM_ARCH_MCM24)
++	    strcat (buf, ", mcm24");
++	  if (e_flags & EF_VISIUM_ARCH_GR6)
++	    strcat (buf, ", gr6");
++	  break;
++
++	case EM_RL78:
++	  switch (e_flags & E_FLAG_RL78_CPU_MASK)
++	    {
++	    case E_FLAG_RL78_ANY_CPU: break;
++	    case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
++	    case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
++	    case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
++	    }
++	  if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
++	    strcat (buf, ", 64-bit doubles");
++	  break;
++
++	case EM_RX:
++	  if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
++	    strcat (buf, ", 64-bit doubles");
++	  if (e_flags & E_FLAG_RX_DSP)
++	    strcat (buf, ", dsp");
++	  if (e_flags & E_FLAG_RX_PID)
++	    strcat (buf, ", pid");
++	  if (e_flags & E_FLAG_RX_ABI)
++	    strcat (buf, ", RX ABI");
++	  if (e_flags & E_FLAG_RX_SINSNS_SET)
++	    strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
++		    ? ", uses String instructions" : ", bans String instructions");
++	  if (e_flags & E_FLAG_RX_V2)
++	    strcat (buf, ", V2");
++	  if (e_flags & E_FLAG_RX_V3)
++	    strcat (buf, ", V3");
++	  break;
++
++	case EM_S390:
++	  if (e_flags & EF_S390_HIGH_GPRS)
++	    strcat (buf, ", highgprs");
++	  break;
++
++	case EM_TI_C6000:
++	  if ((e_flags & EF_C6000_REL))
++	    strcat (buf, ", relocatable module");
++	  break;
++
++	case EM_MSP430:
++	  strcat (buf, _(": architecture variant: "));
++	  switch (e_flags & EF_MSP430_MACH)
++	    {
++	    case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
++	    case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
++	    case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
++	    case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
++	    case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
++	    case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
++	    case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
++	    case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
++	    case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
++	    case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
++	    case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
++	    case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
++	    case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
++	    case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
++	    case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
++	    default:
++	      strcat (buf, _(": unknown")); break;
++	    }
++
++	  if (e_flags & ~ EF_MSP430_MACH)
++	    strcat (buf, _(": unknown extra flag bits also present"));
++	  break;
++
++	case EM_Z80:
++	  switch (e_flags & EF_Z80_MACH_MSK)
++	    {
++	    case EF_Z80_MACH_Z80: strcat (buf, ", Z80"); break;
++	    case EF_Z80_MACH_Z180: strcat (buf, ", Z180"); break;
++	    case EF_Z80_MACH_R800: strcat (buf, ", R800"); break;
++	    case EF_Z80_MACH_EZ80_Z80: strcat (buf, ", EZ80"); break;
++	    case EF_Z80_MACH_EZ80_ADL: strcat (buf, ", EZ80, ADL"); break;
++	    case EF_Z80_MACH_GBZ80: strcat (buf, ", GBZ80"); break;
++	    case EF_Z80_MACH_Z80N: strcat (buf, ", Z80N"); break;
++	    default:
++	      strcat (buf, _(", unknown")); break;
++	    }
++	  break;
++	}
++    }
++
++  return buf;
++}
++
++static const char *
++get_osabi_name (Filedata * filedata, unsigned int osabi)
++{
++  static char buff[32];
++
++  switch (osabi)
++    {
++    case ELFOSABI_NONE:		return "UNIX - System V";
++    case ELFOSABI_HPUX:		return "UNIX - HP-UX";
++    case ELFOSABI_NETBSD:	return "UNIX - NetBSD";
++    case ELFOSABI_GNU:		return "UNIX - GNU";
++    case ELFOSABI_SOLARIS:	return "UNIX - Solaris";
++    case ELFOSABI_AIX:		return "UNIX - AIX";
++    case ELFOSABI_IRIX:		return "UNIX - IRIX";
++    case ELFOSABI_FREEBSD:	return "UNIX - FreeBSD";
++    case ELFOSABI_TRU64:	return "UNIX - TRU64";
++    case ELFOSABI_MODESTO:	return "Novell - Modesto";
++    case ELFOSABI_OPENBSD:	return "UNIX - OpenBSD";
++    case ELFOSABI_OPENVMS:	return "VMS - OpenVMS";
++    case ELFOSABI_NSK:		return "HP - Non-Stop Kernel";
++    case ELFOSABI_AROS:		return "AROS";
++    case ELFOSABI_FENIXOS:	return "FenixOS";
++    case ELFOSABI_CLOUDABI:	return "Nuxi CloudABI";
++    case ELFOSABI_OPENVOS:	return "Stratus Technologies OpenVOS";
++    default:
++      if (osabi >= 64)
++	switch (filedata->file_header.e_machine)
++	  {
++	  case EM_ARM:
++	    switch (osabi)
++	      {
++	      case ELFOSABI_ARM:	return "ARM";
++	      case ELFOSABI_ARM_FDPIC:	return "ARM FDPIC";
++	      default:
++		break;
++	      }
++	    break;
++
++	  case EM_MSP430:
++	  case EM_MSP430_OLD:
++	  case EM_VISIUM:
++	    switch (osabi)
++	      {
++	      case ELFOSABI_STANDALONE:	return _("Standalone App");
++	      default:
++		break;
++	      }
++	    break;
++
++	  case EM_TI_C6000:
++	    switch (osabi)
++	      {
++	      case ELFOSABI_C6000_ELFABI:	return _("Bare-metal C6000");
++	      case ELFOSABI_C6000_LINUX:	return "Linux C6000";
++	      default:
++		break;
++	      }
++	    break;
++
++	  default:
++	    break;
++	  }
++      snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
++      return buff;
++    }
++}
++
++static const char *
++get_aarch64_segment_type (unsigned long type)
++{
++  switch (type)
++    {
++    case PT_AARCH64_ARCHEXT:  return "AARCH64_ARCHEXT";
++    default:                  return NULL;
++    }
++}
++
++static const char *
++get_arm_segment_type (unsigned long type)
++{
++  switch (type)
++    {
++    case PT_ARM_EXIDX: return "EXIDX";
++    default:           return NULL;
++    }
++}
++
++static const char *
++get_s390_segment_type (unsigned long type)
++{
++  switch (type)
++    {
++    case PT_S390_PGSTE: return "S390_PGSTE";
++    default:            return NULL;
++    }
++}
++
++static const char *
++get_mips_segment_type (unsigned long type)
++{
++  switch (type)
++    {
++    case PT_MIPS_REGINFO:   return "REGINFO";
++    case PT_MIPS_RTPROC:    return "RTPROC";
++    case PT_MIPS_OPTIONS:   return "OPTIONS";
++    case PT_MIPS_ABIFLAGS:  return "ABIFLAGS";
++    default:                return NULL;
++    }
++}
++
++static const char *
++get_parisc_segment_type (unsigned long type)
++{
++  switch (type)
++    {
++    case PT_PARISC_ARCHEXT:	return "PARISC_ARCHEXT";
++    case PT_PARISC_UNWIND:	return "PARISC_UNWIND";
++    case PT_PARISC_WEAKORDER:	return "PARISC_WEAKORDER";
++    default:                    return NULL;
++    }
++}
++
++static const char *
++get_ia64_segment_type (unsigned long type)
++{
++  switch (type)
++    {
++    case PT_IA_64_ARCHEXT:	return "IA_64_ARCHEXT";
++    case PT_IA_64_UNWIND:	return "IA_64_UNWIND";
++    default:                    return NULL;
++    }
++}
++
++static const char *
++get_tic6x_segment_type (unsigned long type)
++{
++  switch (type)
++    {
++    case PT_C6000_PHATTR:  return "C6000_PHATTR";
++    default:               return NULL;
++    }
++}
++
++static const char *
++get_hpux_segment_type (unsigned long type, unsigned e_machine)
++{
++  if (e_machine == EM_PARISC)
++    switch (type)
++      {
++      case PT_HP_TLS:		return "HP_TLS";
++      case PT_HP_CORE_NONE:	return "HP_CORE_NONE";
++      case PT_HP_CORE_VERSION:	return "HP_CORE_VERSION";
++      case PT_HP_CORE_KERNEL:	return "HP_CORE_KERNEL";
++      case PT_HP_CORE_COMM:	return "HP_CORE_COMM";
++      case PT_HP_CORE_PROC:	return "HP_CORE_PROC";
++      case PT_HP_CORE_LOADABLE:	return "HP_CORE_LOADABLE";
++      case PT_HP_CORE_STACK:	return "HP_CORE_STACK";
++      case PT_HP_CORE_SHM:	return "HP_CORE_SHM";
++      case PT_HP_CORE_MMF:	return "HP_CORE_MMF";
++      case PT_HP_PARALLEL:	return "HP_PARALLEL";
++      case PT_HP_FASTBIND:	return "HP_FASTBIND";
++      case PT_HP_OPT_ANNOT:	return "HP_OPT_ANNOT";
++      case PT_HP_HSL_ANNOT:	return "HP_HSL_ANNOT";
++      case PT_HP_STACK:		return "HP_STACK";
++      case PT_HP_CORE_UTSNAME:	return "HP_CORE_UTSNAME";
++      default:			return NULL;
++      }
++
++  if (e_machine == EM_IA_64)
++    switch (type)
++      {
++      case PT_HP_TLS:		 return "HP_TLS";
++      case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
++      case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
++      case PT_IA_64_HP_STACK:	 return "HP_STACK";
++      default:			 return NULL;
++      }
++
++  return NULL;
++}
++
++static const char *
++get_solaris_segment_type (unsigned long type)
++{
++  switch (type)
++    {
++    case 0x6464e550: return "PT_SUNW_UNWIND";
++    case 0x6474e550: return "PT_SUNW_EH_FRAME";
++    case 0x6ffffff7: return "PT_LOSUNW";
++    case 0x6ffffffa: return "PT_SUNWBSS";
++    case 0x6ffffffb: return "PT_SUNWSTACK";
++    case 0x6ffffffc: return "PT_SUNWDTRACE";
++    case 0x6ffffffd: return "PT_SUNWCAP";
++    case 0x6fffffff: return "PT_HISUNW";
++    default:         return NULL;
++    }
++}
++
++static const char *
++get_segment_type (Filedata * filedata, unsigned long p_type)
++{
++  static char buff[32];
++
++  switch (p_type)
++    {
++    case PT_NULL:	return "NULL";
++    case PT_LOAD:	return "LOAD";
++    case PT_DYNAMIC:	return "DYNAMIC";
++    case PT_INTERP:	return "INTERP";
++    case PT_NOTE:	return "NOTE";
++    case PT_SHLIB:	return "SHLIB";
++    case PT_PHDR:	return "PHDR";
++    case PT_TLS:	return "TLS";
++    case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
++    case PT_GNU_STACK:	return "GNU_STACK";
++    case PT_GNU_RELRO:  return "GNU_RELRO";
++    case PT_GNU_PROPERTY: return "GNU_PROPERTY";
++
++    case PT_OPENBSD_RANDOMIZE: return "OPENBSD_RANDOMIZE";
++    case PT_OPENBSD_WXNEEDED: return "OPENBSD_WXNEEDED";
++    case PT_OPENBSD_BOOTDATA: return "OPENBSD_BOOTDATA";
++
++    default:
++      if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
++	{
++	  const char * result;
++
++	  switch (filedata->file_header.e_machine)
++	    {
++	    case EM_AARCH64:
++	      result = get_aarch64_segment_type (p_type);
++	      break;
++	    case EM_ARM:
++	      result = get_arm_segment_type (p_type);
++	      break;
++	    case EM_MIPS:
++	    case EM_MIPS_RS3_LE:
++	      result = get_mips_segment_type (p_type);
++	      break;
++	    case EM_PARISC:
++	      result = get_parisc_segment_type (p_type);
++	      break;
++	    case EM_IA_64:
++	      result = get_ia64_segment_type (p_type);
++	      break;
++	    case EM_TI_C6000:
++	      result = get_tic6x_segment_type (p_type);
++	      break;
++	    case EM_S390:
++	    case EM_S390_OLD:
++	      result = get_s390_segment_type (p_type);
++	      break;
++	    default:
++	      result = NULL;
++	      break;
++	    }
++
++	  if (result != NULL)
++	    return result;
++
++	  sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
++	}
++      else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
++	{
++	  const char * result = NULL;
++
++	  switch (filedata->file_header.e_ident[EI_OSABI])
++	    {
++	    case ELFOSABI_GNU:
++	    case ELFOSABI_FREEBSD:
++	      if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
++		{
++		  sprintf (buff, "GNU_MBIND+%#lx", p_type - PT_GNU_MBIND_LO);
++		  result = buff;
++		}
++	      break;
++	    case ELFOSABI_HPUX:
++	      result = get_hpux_segment_type (p_type,
++					      filedata->file_header.e_machine);
++	      break;
++	    case ELFOSABI_SOLARIS:
++	      result = get_solaris_segment_type (p_type);
++	      break;
++	    default:
++	      break;
++	    }
++	  if (result != NULL)
++	    return result;
++
++	  sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
++	}
++      else
++	snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
++
++      return buff;
++    }
++}
++
++static const char *
++get_arc_section_type_name (unsigned int sh_type)
++{
++  switch (sh_type)
++    {
++    case SHT_ARC_ATTRIBUTES:      return "ARC_ATTRIBUTES";
++    default:
++      break;
++    }
++  return NULL;
++}
++
++static const char *
++get_mips_section_type_name (unsigned int sh_type)
++{
++  switch (sh_type)
++    {
++    case SHT_MIPS_LIBLIST:	 return "MIPS_LIBLIST";
++    case SHT_MIPS_MSYM:		 return "MIPS_MSYM";
++    case SHT_MIPS_CONFLICT:	 return "MIPS_CONFLICT";
++    case SHT_MIPS_GPTAB:	 return "MIPS_GPTAB";
++    case SHT_MIPS_UCODE:	 return "MIPS_UCODE";
++    case SHT_MIPS_DEBUG:	 return "MIPS_DEBUG";
++    case SHT_MIPS_REGINFO:	 return "MIPS_REGINFO";
++    case SHT_MIPS_PACKAGE:	 return "MIPS_PACKAGE";
++    case SHT_MIPS_PACKSYM:	 return "MIPS_PACKSYM";
++    case SHT_MIPS_RELD:		 return "MIPS_RELD";
++    case SHT_MIPS_IFACE:	 return "MIPS_IFACE";
++    case SHT_MIPS_CONTENT:	 return "MIPS_CONTENT";
++    case SHT_MIPS_OPTIONS:	 return "MIPS_OPTIONS";
++    case SHT_MIPS_SHDR:		 return "MIPS_SHDR";
++    case SHT_MIPS_FDESC:	 return "MIPS_FDESC";
++    case SHT_MIPS_EXTSYM:	 return "MIPS_EXTSYM";
++    case SHT_MIPS_DENSE:	 return "MIPS_DENSE";
++    case SHT_MIPS_PDESC:	 return "MIPS_PDESC";
++    case SHT_MIPS_LOCSYM:	 return "MIPS_LOCSYM";
++    case SHT_MIPS_AUXSYM:	 return "MIPS_AUXSYM";
++    case SHT_MIPS_OPTSYM:	 return "MIPS_OPTSYM";
++    case SHT_MIPS_LOCSTR:	 return "MIPS_LOCSTR";
++    case SHT_MIPS_LINE:		 return "MIPS_LINE";
++    case SHT_MIPS_RFDESC:	 return "MIPS_RFDESC";
++    case SHT_MIPS_DELTASYM:	 return "MIPS_DELTASYM";
++    case SHT_MIPS_DELTAINST:	 return "MIPS_DELTAINST";
++    case SHT_MIPS_DELTACLASS:	 return "MIPS_DELTACLASS";
++    case SHT_MIPS_DWARF:	 return "MIPS_DWARF";
++    case SHT_MIPS_DELTADECL:	 return "MIPS_DELTADECL";
++    case SHT_MIPS_SYMBOL_LIB:	 return "MIPS_SYMBOL_LIB";
++    case SHT_MIPS_EVENTS:	 return "MIPS_EVENTS";
++    case SHT_MIPS_TRANSLATE:	 return "MIPS_TRANSLATE";
++    case SHT_MIPS_PIXIE:	 return "MIPS_PIXIE";
++    case SHT_MIPS_XLATE:	 return "MIPS_XLATE";
++    case SHT_MIPS_XLATE_DEBUG:	 return "MIPS_XLATE_DEBUG";
++    case SHT_MIPS_WHIRL:	 return "MIPS_WHIRL";
++    case SHT_MIPS_EH_REGION:	 return "MIPS_EH_REGION";
++    case SHT_MIPS_XLATE_OLD:	 return "MIPS_XLATE_OLD";
++    case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
++    case SHT_MIPS_ABIFLAGS:	 return "MIPS_ABIFLAGS";
++    case SHT_MIPS_XHASH:	 return "MIPS_XHASH";
++    default:
++      break;
++    }
++  return NULL;
++}
++
++static const char *
++get_parisc_section_type_name (unsigned int sh_type)
++{
++  switch (sh_type)
++    {
++    case SHT_PARISC_EXT:	return "PARISC_EXT";
++    case SHT_PARISC_UNWIND:	return "PARISC_UNWIND";
++    case SHT_PARISC_DOC:	return "PARISC_DOC";
++    case SHT_PARISC_ANNOT:	return "PARISC_ANNOT";
++    case SHT_PARISC_SYMEXTN:	return "PARISC_SYMEXTN";
++    case SHT_PARISC_STUBS:	return "PARISC_STUBS";
++    case SHT_PARISC_DLKM:	return "PARISC_DLKM";
++    default:             	return NULL;
++    }
++}
++
++static const char *
++get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
++{
++  /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
++  if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
++    return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
++
++  switch (sh_type)
++    {
++    case SHT_IA_64_EXT:		       return "IA_64_EXT";
++    case SHT_IA_64_UNWIND:	       return "IA_64_UNWIND";
++    case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
++    case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
++    case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
++    case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
++    case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
++    case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
++    case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
++    case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
++    default:
++      break;
++    }
++  return NULL;
++}
++
++static const char *
++get_x86_64_section_type_name (unsigned int sh_type)
++{
++  switch (sh_type)
++    {
++    case SHT_X86_64_UNWIND:	return "X86_64_UNWIND";
++    default:			return NULL;
++    }
++}
++
++static const char *
++get_aarch64_section_type_name (unsigned int sh_type)
++{
++  switch (sh_type)
++    {
++    case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
++    default:			 return NULL;
++    }
++}
++
++static const char *
++get_arm_section_type_name (unsigned int sh_type)
++{
++  switch (sh_type)
++    {
++    case SHT_ARM_EXIDX:           return "ARM_EXIDX";
++    case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
++    case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
++    case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
++    case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
++    default:			  return NULL;
++    }
++}
++
++static const char *
++get_tic6x_section_type_name (unsigned int sh_type)
++{
++  switch (sh_type)
++    {
++    case SHT_C6000_UNWIND:      return "C6000_UNWIND";
++    case SHT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
++    case SHT_C6000_ATTRIBUTES:  return "C6000_ATTRIBUTES";
++    case SHT_TI_ICODE:          return "TI_ICODE";
++    case SHT_TI_XREF:           return "TI_XREF";
++    case SHT_TI_HANDLER:        return "TI_HANDLER";
++    case SHT_TI_INITINFO:       return "TI_INITINFO";
++    case SHT_TI_PHATTRS:        return "TI_PHATTRS";
++    default:                    return NULL;
++    }
++}
++
++static const char *
++get_msp430_section_type_name (unsigned int sh_type)
++{
++  switch (sh_type)
++    {
++    case SHT_MSP430_SEC_FLAGS:    return "MSP430_SEC_FLAGS";
++    case SHT_MSP430_SYM_ALIASES:  return "MSP430_SYM_ALIASES";
++    case SHT_MSP430_ATTRIBUTES:   return "MSP430_ATTRIBUTES";
++    default:                      return NULL;
++    }
++}
++
++static const char *
++get_nfp_section_type_name (unsigned int sh_type)
++{
++  switch (sh_type)
++    {
++    case SHT_NFP_MECONFIG:	return "NFP_MECONFIG";
++    case SHT_NFP_INITREG:	return "NFP_INITREG";
++    case SHT_NFP_UDEBUG:	return "NFP_UDEBUG";
++    default:			return NULL;
++    }
++}
++
++static const char *
++get_v850_section_type_name (unsigned int sh_type)
++{
++  switch (sh_type)
++    {
++    case SHT_V850_SCOMMON:  return "V850 Small Common";
++    case SHT_V850_TCOMMON:  return "V850 Tiny Common";
++    case SHT_V850_ZCOMMON:  return "V850 Zero Common";
++    case SHT_RENESAS_IOP:   return "RENESAS IOP";
++    case SHT_RENESAS_INFO:  return "RENESAS INFO";
++    default:                return NULL;
++    }
++}
++
++static const char *
++get_riscv_section_type_name (unsigned int sh_type)
++{
++  switch (sh_type)
++    {
++    case SHT_RISCV_ATTRIBUTES:  return "RISCV_ATTRIBUTES";
++    default: return NULL;
++    }
++}
++
++static const char *
++get_csky_section_type_name (unsigned int sh_type)
++{
++  switch (sh_type)
++    {
++    case SHT_CSKY_ATTRIBUTES:  return "CSKY_ATTRIBUTES";
++    default:  return NULL;
++    }
++}
++
++static const char *
++get_section_type_name (Filedata * filedata, unsigned int sh_type)
++{
++  static char buff[32];
++  const char * result;
++
++  switch (sh_type)
++    {
++    case SHT_NULL:		return "NULL";
++    case SHT_PROGBITS:		return "PROGBITS";
++    case SHT_SYMTAB:		return "SYMTAB";
++    case SHT_STRTAB:		return "STRTAB";
++    case SHT_RELA:		return "RELA";
++    case SHT_HASH:		return "HASH";
++    case SHT_DYNAMIC:		return "DYNAMIC";
++    case SHT_NOTE:		return "NOTE";
++    case SHT_NOBITS:		return "NOBITS";
++    case SHT_REL:		return "REL";
++    case SHT_SHLIB:		return "SHLIB";
++    case SHT_DYNSYM:		return "DYNSYM";
++    case SHT_INIT_ARRAY:	return "INIT_ARRAY";
++    case SHT_FINI_ARRAY:	return "FINI_ARRAY";
++    case SHT_PREINIT_ARRAY:	return "PREINIT_ARRAY";
++    case SHT_GNU_HASH:		return "GNU_HASH";
++    case SHT_GROUP:		return "GROUP";
++    case SHT_SYMTAB_SHNDX:	return "SYMTAB SECTION INDICES";
++    case SHT_GNU_verdef:	return "VERDEF";
++    case SHT_GNU_verneed:	return "VERNEED";
++    case SHT_GNU_versym:	return "VERSYM";
++    case 0x6ffffff0:		return "VERSYM";
++    case 0x6ffffffc:		return "VERDEF";
++    case 0x7ffffffd:		return "AUXILIARY";
++    case 0x7fffffff:		return "FILTER";
++    case SHT_GNU_LIBLIST:	return "GNU_LIBLIST";
++
++    default:
++      if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
++	{
++	  switch (filedata->file_header.e_machine)
++	    {
++	    case EM_ARC:
++	    case EM_ARC_COMPACT:
++	    case EM_ARC_COMPACT2:
++	      result = get_arc_section_type_name (sh_type);
++	      break;
++	    case EM_MIPS:
++	    case EM_MIPS_RS3_LE:
++	      result = get_mips_section_type_name (sh_type);
++	      break;
++	    case EM_PARISC:
++	      result = get_parisc_section_type_name (sh_type);
++	      break;
++	    case EM_IA_64:
++	      result = get_ia64_section_type_name (filedata, sh_type);
++	      break;
++	    case EM_X86_64:
++	    case EM_L1OM:
++	    case EM_K1OM:
++	      result = get_x86_64_section_type_name (sh_type);
++	      break;
++	    case EM_AARCH64:
++	      result = get_aarch64_section_type_name (sh_type);
++	      break;
++	    case EM_ARM:
++	      result = get_arm_section_type_name (sh_type);
++	      break;
++	    case EM_TI_C6000:
++	      result = get_tic6x_section_type_name (sh_type);
++	      break;
++	    case EM_MSP430:
++	      result = get_msp430_section_type_name (sh_type);
++	      break;
++	    case EM_NFP:
++	      result = get_nfp_section_type_name (sh_type);
++	      break;
++	    case EM_V800:
++	    case EM_V850:
++	    case EM_CYGNUS_V850:
++	      result = get_v850_section_type_name (sh_type);
++	      break;
++	    case EM_RISCV:
++	      result = get_riscv_section_type_name (sh_type);
++	      break;
++	    case EM_CSKY:
++	      result = get_csky_section_type_name (sh_type);
++	      break;
++	    default:
++	      result = NULL;
++	      break;
++	    }
++
++	  if (result != NULL)
++	    return result;
++
++	  sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
++	}
++      else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
++	{
++	  switch (filedata->file_header.e_machine)
++	    {
++	    case EM_IA_64:
++	      result = get_ia64_section_type_name (filedata, sh_type);
++	      break;
++	    default:
++	      if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
++		result = get_solaris_section_type (sh_type);
++	      else
++		{
++		  switch (sh_type)
++		    {
++		    case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
++		    case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
++		    case SHT_GNU_HASH: result = "GNU_HASH"; break;
++		    case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
++		    default:
++		      result = NULL;
++		      break;
++		    }
++		}
++	      break;
++	    }
++
++	  if (result != NULL)
++	    return result;
++
++	  sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
++	}
++      else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
++	{
++	  switch (filedata->file_header.e_machine)
++	    {
++	    case EM_V800:
++	    case EM_V850:
++	    case EM_CYGNUS_V850:
++	      result = get_v850_section_type_name (sh_type);
++	      break;
++	    default:
++	      result = NULL;
++	      break;
++	    }
++
++	  if (result != NULL)
++	    return result;
++
++	  sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
++	}
++      else
++	/* This message is probably going to be displayed in a 15
++	   character wide field, so put the hex value first.  */
++	snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
++
++      return buff;
++    }
++}
++
++enum long_option_values
++{
++  OPTION_DEBUG_DUMP = 512,
++  OPTION_DYN_SYMS,
++  OPTION_LTO_SYMS,
++  OPTION_DWARF_DEPTH,
++  OPTION_DWARF_START,
++  OPTION_DWARF_CHECK,
++  OPTION_CTF_DUMP,
++  OPTION_CTF_PARENT,
++  OPTION_CTF_SYMBOLS,
++  OPTION_CTF_STRINGS,
++  OPTION_WITH_SYMBOL_VERSIONS,
++  OPTION_RECURSE_LIMIT,
++  OPTION_NO_RECURSE_LIMIT,
++  OPTION_NO_DEMANGLING,
++  OPTION_SYM_BASE
++};
++
++static struct option options[] =
++{
++ /* Note - This table is alpha-sorted on the 'val'
++    field in order to make adding new options easier.  */
++  {"arch-specific",    no_argument, 0, 'A'},
++  {"all",	       no_argument, 0, 'a'},
++  {"demangle",         optional_argument, 0, 'C'},
++  {"archive-index",    no_argument, 0, 'c'},
++  {"use-dynamic",      no_argument, 0, 'D'},
++  {"dynamic",	       no_argument, 0, 'd'},
++  {"headers",	       no_argument, 0, 'e'},
++  {"section-groups",   no_argument, 0, 'g'},
++  {"help",	       no_argument, 0, 'H'},
++  {"file-header",      no_argument, 0, 'h'},
++  {"histogram",	       no_argument, 0, 'I'},
++  {"lint",             no_argument, 0, 'L'},
++  {"enable-checks",    no_argument, 0, 'L'},
++  {"program-headers",  no_argument, 0, 'l'},
++  {"segments",	       no_argument, 0, 'l'},
++  {"full-section-name",no_argument, 0, 'N'},
++  {"notes",	       no_argument, 0, 'n'},
++  {"process-links",    no_argument, 0, 'P'},
++  {"string-dump",      required_argument, 0, 'p'},
++  {"relocated-dump",   required_argument, 0, 'R'},
++  {"relocs",	       no_argument, 0, 'r'},
++  {"section-headers",  no_argument, 0, 'S'},
++  {"sections",	       no_argument, 0, 'S'},
++  {"symbols",	       no_argument, 0, 's'},
++  {"syms",	       no_argument, 0, 's'},
++  {"silent-truncation",no_argument, 0, 'T'},
++  {"section-details",  no_argument, 0, 't'},
++  {"unwind",	       no_argument, 0, 'u'},
++  {"version-info",     no_argument, 0, 'V'},
++  {"version",	       no_argument, 0, 'v'},
++  {"wide",	       no_argument, 0, 'W'},
++  {"hex-dump",	       required_argument, 0, 'x'},
++  {"decompress",       no_argument, 0, 'z'},
++
++  {"no-demangle",      no_argument, 0, OPTION_NO_DEMANGLING},
++  {"recurse-limit",    no_argument, NULL, OPTION_RECURSE_LIMIT},
++  {"no-recurse-limit", no_argument, NULL, OPTION_NO_RECURSE_LIMIT},
++  {"no-recursion-limit", no_argument, NULL, OPTION_NO_RECURSE_LIMIT},
++  {"dyn-syms",	       no_argument, 0, OPTION_DYN_SYMS},
++  {"lto-syms",         no_argument, 0, OPTION_LTO_SYMS},
++  {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
++  {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
++  {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
++  {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
++#ifdef ENABLE_LIBCTF
++  {"ctf",	       required_argument, 0, OPTION_CTF_DUMP},
++  {"ctf-symbols",      required_argument, 0, OPTION_CTF_SYMBOLS},
++  {"ctf-strings",      required_argument, 0, OPTION_CTF_STRINGS},
++  {"ctf-parent",       required_argument, 0, OPTION_CTF_PARENT},
++#endif
++  {"sym-base",	       optional_argument, 0, OPTION_SYM_BASE},
++
++  {0,		       no_argument, 0, 0}
++};
++
++static void
++usage (FILE * stream)
++{
++  fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
++  fprintf (stream, _(" Display information about the contents of ELF format files\n"));
++  fprintf (stream, _(" Options are:\n"));
++  fprintf (stream, _("\
++  -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
++  fprintf (stream, _("\
++  -h --file-header       Display the ELF file header\n"));
++  fprintf (stream, _("\
++  -l --program-headers   Display the program headers\n"));
++  fprintf (stream, _("\
++     --segments          An alias for --program-headers\n"));
++  fprintf (stream, _("\
++  -S --section-headers   Display the sections' header\n"));
++  fprintf (stream, _("\
++     --sections          An alias for --section-headers\n"));
++  fprintf (stream, _("\
++  -g --section-groups    Display the section groups\n"));
++  fprintf (stream, _("\
++  -t --section-details   Display the section details\n"));
++  fprintf (stream, _("\
++  -e --headers           Equivalent to: -h -l -S\n"));
++  fprintf (stream, _("\
++  -s --syms              Display the symbol table\n"));
++  fprintf (stream, _("\
++     --symbols           An alias for --syms\n"));
++  fprintf (stream, _("\
++     --dyn-syms          Display the dynamic symbol table\n"));
++  fprintf (stream, _("\
++     --lto-syms          Display LTO symbol tables\n"));
++  fprintf (stream, _("\
++     --sym-base=[0|8|10|16] \n\
++                         Force base for symbol sizes.  The options are \n\
++                         mixed (the default), octal, decimal, hexadecimal.\n"));
++  fprintf (stream, _("\
++  -C --demangle[=STYLE]  Decode low-level symbol names into user-level names\n\
++                          The STYLE, if specified, can be `auto' (the default),\n\
++                          `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
++                          or `gnat'\n"));
++  fprintf (stream, _("\
++     --no-demangle       Do not demangle low-level symbol names.  (default)\n"));
++  fprintf (stream, _("\
++     --recurse-limit     Enable a demangling recursion limit.  (default)\n"));
++  fprintf (stream, _("\
++     --no-recurse-limit  Disable a demangling recursion limit\n"));
++  fprintf (stream, _("\
++  -n --notes             Display the core notes (if present)\n"));
++  fprintf (stream, _("\
++  -r --relocs            Display the relocations (if present)\n"));
++  fprintf (stream, _("\
++  -u --unwind            Display the unwind info (if present)\n"));
++  fprintf (stream, _("\
++  -d --dynamic           Display the dynamic section (if present)\n"));
++  fprintf (stream, _("\
++  -V --version-info      Display the version sections (if present)\n"));
++  fprintf (stream, _("\
++  -A --arch-specific     Display architecture specific information (if any)\n"));
++  fprintf (stream, _("\
++  -c --archive-index     Display the symbol/file index in an archive\n"));
++  fprintf (stream, _("\
++  -D --use-dynamic       Use the dynamic section info when displaying symbols\n"));
++  fprintf (stream, _("\
++  -L --lint|--enable-checks\n\
++                         Display warning messages for possible problems\n"));
++  fprintf (stream, _("\
++  -x --hex-dump=<number|name>\n\
++                         Dump the contents of section <number|name> as bytes\n"));
++  fprintf (stream, _("\
++  -p --string-dump=<number|name>\n\
++                         Dump the contents of section <number|name> as strings\n"));
++  fprintf (stream, _("\
++  -R --relocated-dump=<number|name>\n\
++                         Dump the relocated contents of section <number|name>\n"));
++  fprintf (stream, _("\
++  -z --decompress        Decompress section before dumping it\n"));
++  fprintf (stream, _("\
++  -w --debug-dump[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 --debug-dump=links Display the contents of sections that link to separate\n\
++                          debuginfo files\n"));
++  fprintf (stream, _("\
++  -P --process-links     Display the contents of non-debug sections in separate\n\
++                          debuginfo files.  (Implies -wK)\n"));
++#if DEFAULT_FOR_FOLLOW_LINKS
++  fprintf (stream, _("\
++  -wK --debug-dump=follow-links\n\
++                         Follow links to separate debug info files (default)\n"));
++  fprintf (stream, _("\
++  -wN --debug-dump=no-follow-links\n\
++                         Do not follow links to separate debug info files\n"));
++#else
++  fprintf (stream, _("\
++  -wK --debug-dump=follow-links\n\
++                         Follow links to separate debug info files\n"));
++  fprintf (stream, _("\
++  -wN --debug-dump=no-follow-links\n\
++                         Do not follow links to separate debug info files\n\
++                          (default)\n"));
++#endif
++  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"));
++#ifdef ENABLE_LIBCTF
++  fprintf (stream, _("\
++  --ctf=<number|name>    Display CTF info from section <number|name>\n"));
++  fprintf (stream, _("\
++  --ctf-parent=<number|name>\n\
++                         Use section <number|name> as the CTF parent\n"));
++  fprintf (stream, _("\
++  --ctf-symbols=<number|name>\n\
++                         Use section <number|name> as the CTF external symtab\n"));
++  fprintf (stream, _("\
++  --ctf-strings=<number|name>\n\
++                         Use section <number|name> as the CTF external strtab\n"));
++#endif
++
++#ifdef SUPPORT_DISASSEMBLY
++  fprintf (stream, _("\
++  -i --instruction-dump=<number|name>\n\
++                         Disassemble the contents of section <number|name>\n"));
++#endif
++  fprintf (stream, _("\
++  -I --histogram         Display histogram of bucket list lengths\n"));
++  fprintf (stream, _("\
++  -W --wide              Allow output width to exceed 80 characters\n"));
++  fprintf (stream, _("\
++  -T --silent-truncation If a symbol name is truncated, do not add [...] suffix\n"));
++  fprintf (stream, _("\
++  @<file>                Read options from <file>\n"));
++  fprintf (stream, _("\
++  -H --help              Display this information\n"));
++  fprintf (stream, _("\
++  -v --version           Display the version number of readelf\n"));
++
++  if (REPORT_BUGS_TO[0] && stream == stdout)
++    fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
++
++  exit (stream == stdout ? 0 : 1);
++}
++
++/* Record the fact that the user wants the contents of section number
++   SECTION to be displayed using the method(s) encoded as flags bits
++   in TYPE.  Note, TYPE can be zero if we are creating the array for
++   the first time.  */
++
++static void
++request_dump_bynumber (struct dump_data *dumpdata,
++		       unsigned int section, dump_type type)
++{
++  if (section >= dumpdata->num_dump_sects)
++    {
++      dump_type * new_dump_sects;
++
++      new_dump_sects = (dump_type *) calloc (section + 1,
++                                             sizeof (* new_dump_sects));
++
++      if (new_dump_sects == NULL)
++	error (_("Out of memory allocating dump request table.\n"));
++      else
++	{
++	  if (dumpdata->dump_sects)
++	    {
++	      /* Copy current flag settings.  */
++	      memcpy (new_dump_sects, dumpdata->dump_sects,
++		      dumpdata->num_dump_sects * sizeof (* new_dump_sects));
++
++	      free (dumpdata->dump_sects);
++	    }
++
++	  dumpdata->dump_sects = new_dump_sects;
++	  dumpdata->num_dump_sects = section + 1;
++	}
++    }
++
++  if (dumpdata->dump_sects)
++    dumpdata->dump_sects[section] |= type;
++}
++
++/* Request a dump by section name.  */
++
++static void
++request_dump_byname (const char * section, dump_type type)
++{
++  struct dump_list_entry * new_request;
++
++  new_request = (struct dump_list_entry *)
++      malloc (sizeof (struct dump_list_entry));
++  if (!new_request)
++    error (_("Out of memory allocating dump request table.\n"));
++
++  new_request->name = strdup (section);
++  if (!new_request->name)
++    error (_("Out of memory allocating dump request table.\n"));
++
++  new_request->type = type;
++
++  new_request->next = dump_sects_byname;
++  dump_sects_byname = new_request;
++}
++
++static inline void
++request_dump (struct dump_data *dumpdata, dump_type type)
++{
++  int section;
++  char * cp;
++
++  do_dump = true;
++  section = strtoul (optarg, & cp, 0);
++
++  if (! *cp && section >= 0)
++    request_dump_bynumber (dumpdata, section, type);
++  else
++    request_dump_byname (optarg, type);
++}
++
++static void
++parse_args (struct dump_data *dumpdata, int argc, char ** argv)
++{
++  int c;
++
++  if (argc < 2)
++    usage (stderr);
++
++  while ((c = getopt_long
++	  (argc, argv, "ACDHILNPR:STVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
++    {
++      switch (c)
++	{
++	case 0:
++	  /* Long options.  */
++	  break;
++	case 'H':
++	  usage (stdout);
++	  break;
++
++	case 'a':
++	  do_syms = true;
++	  do_reloc = true;
++	  do_unwind = true;
++	  do_dynamic = true;
++	  do_header = true;
++	  do_sections = true;
++	  do_section_groups = true;
++	  do_segments = true;
++	  do_version = true;
++	  do_histogram = true;
++	  do_arch = true;
++	  do_notes = true;
++	  break;
++
++	case 'g':
++	  do_section_groups = true;
++	  break;
++	case 't':
++	case 'N':
++	  do_sections = true;
++	  do_section_details = true;
++	  break;
++	case 'e':
++	  do_header = true;
++	  do_sections = true;
++	  do_segments = true;
++	  break;
++	case 'A':
++	  do_arch = true;
++	  break;
++	case 'D':
++	  do_using_dynamic = true;
++	  break;
++	case 'r':
++	  do_reloc = true;
++	  break;
++	case 'u':
++	  do_unwind = true;
++	  break;
++	case 'h':
++	  do_header = true;
++	  break;
++	case 'l':
++	  do_segments = true;
++	  break;
++	case 's':
++	  do_syms = true;
++	  break;
++	case 'S':
++	  do_sections = true;
++	  break;
++	case 'd':
++	  do_dynamic = true;
++	  break;
++	case 'I':
++	  do_histogram = true;
++	  break;
++	case 'n':
++	  do_notes = true;
++	  break;
++	case 'c':
++	  do_archive_index = true;
++	  break;
++	case 'L':
++	  do_checks = true;
++	  break;
++	case 'P':
++	  process_links = true;
++	  do_follow_links = true;
++	  break;
++	case 'x':
++	  request_dump (dumpdata, HEX_DUMP);
++	  break;
++	case 'p':
++	  request_dump (dumpdata, STRING_DUMP);
++	  break;
++	case 'R':
++	  request_dump (dumpdata, RELOC_DUMP);
++	  break;
++	case 'z':
++	  decompress_dumps = true;
++	  break;
++	case 'w':
++	  do_dump = true;
++	  if (optarg == NULL)
++	    {
++	      do_debugging = true;
++	      dwarf_select_sections_all ();
++	    }
++	  else
++	    {
++	      do_debugging = false;
++	      dwarf_select_sections_by_letters (optarg);
++	    }
++	  break;
++	case OPTION_DEBUG_DUMP:
++	  do_dump = true;
++	  if (optarg == NULL)
++	    {
++	      do_debugging = true;
++	      dwarf_select_sections_all ();
++	    }
++	  else
++	    {
++	      do_debugging = false;
++	      dwarf_select_sections_by_names (optarg);
++	    }
++	  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);
++	  }
++	  break;
++	case OPTION_DWARF_CHECK:
++	  dwarf_check = true;
++	  break;
++	case OPTION_CTF_DUMP:
++	  do_ctf = true;
++	  request_dump (dumpdata, CTF_DUMP);
++	  break;
++	case OPTION_CTF_SYMBOLS:
++	  free (dump_ctf_symtab_name);
++	  dump_ctf_symtab_name = strdup (optarg);
++	  break;
++	case OPTION_CTF_STRINGS:
++	  free (dump_ctf_strtab_name);
++	  dump_ctf_strtab_name = strdup (optarg);
++	  break;
++	case OPTION_CTF_PARENT:
++	  free (dump_ctf_parent_name);
++	  dump_ctf_parent_name = strdup (optarg);
++	  break;
++	case OPTION_DYN_SYMS:
++	  do_dyn_syms = true;
++	  break;
++	case OPTION_LTO_SYMS:
++	  do_lto_syms = true;
++	  break;
++#ifdef SUPPORT_DISASSEMBLY
++	case 'i':
++	  request_dump (dumpdata, DISASS_DUMP);
++	  break;
++#endif
++	case 'v':
++	  print_version (program_name);
++	  break;
++	case 'V':
++	  do_version = true;
++	  break;
++	case 'W':
++	  do_wide = true;
++	  break;
++	case 'T':
++	  do_not_show_symbol_truncation = true;
++	  break;
++	case 'C':
++	  do_demangle = true;
++	  if (optarg != NULL)
++	    {
++	      enum demangling_styles style;
++
++	      style = cplus_demangle_name_to_style (optarg);
++	      if (style == unknown_demangling)
++		error (_("unknown demangling style `%s'"), optarg);
++
++	      cplus_demangle_set_style (style);
++	    }
++	  break;
++	case OPTION_NO_DEMANGLING:
++	  do_demangle = false;
++	  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 OPTION_WITH_SYMBOL_VERSIONS:
++	  /* Ignored for backward compatibility.  */
++	  break;
++
++	case OPTION_SYM_BASE:
++	  sym_base = 0;
++	  if (optarg != NULL)
++	    {
++	      sym_base = strtoul (optarg, NULL, 0);
++	      switch (sym_base)
++		{
++		  case 0:
++		  case 8:
++		  case 10:
++		  case 16:
++		    break;
++
++		  default:
++		    sym_base = 0;
++		    break;
++		}
++	    }
++	  break;
++
++	default:
++	  /* xgettext:c-format */
++	  error (_("Invalid option '-%c'\n"), c);
++	  /* Fall through.  */
++	case '?':
++	  usage (stderr);
++	}
++    }
++
++  if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
++      && !do_segments && !do_header && !do_dump && !do_version
++      && !do_histogram && !do_debugging && !do_arch && !do_notes
++      && !do_section_groups && !do_archive_index
++      && !do_dyn_syms && !do_lto_syms)
++    {
++      if (do_checks)
++	{
++	  check_all = true;
++	  do_dynamic = do_syms = do_reloc = do_unwind = do_sections = true;
++	  do_segments = do_header = do_dump = do_version = true;
++	  do_histogram = do_debugging = do_arch = do_notes = true;
++	  do_section_groups = do_archive_index = do_dyn_syms = true;
++	  do_lto_syms = true;
++	}
++      else
++	usage (stderr);
++    }
++}
++
++static const char *
++get_elf_class (unsigned int elf_class)
++{
++  static char buff[32];
++
++  switch (elf_class)
++    {
++    case ELFCLASSNONE: return _("none");
++    case ELFCLASS32:   return "ELF32";
++    case ELFCLASS64:   return "ELF64";
++    default:
++      snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
++      return buff;
++    }
++}
++
++static const char *
++get_data_encoding (unsigned int encoding)
++{
++  static char buff[32];
++
++  switch (encoding)
++    {
++    case ELFDATANONE: return _("none");
++    case ELFDATA2LSB: return _("2's complement, little endian");
++    case ELFDATA2MSB: return _("2's complement, big endian");
++    default:
++      snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
++      return buff;
++    }
++}
++
++/* Decode the data held in 'filedata->file_header'.  */
++
++static bool
++process_file_header (Filedata * filedata)
++{
++  Elf_Internal_Ehdr * header = & filedata->file_header;
++
++  if (   header->e_ident[EI_MAG0] != ELFMAG0
++      || header->e_ident[EI_MAG1] != ELFMAG1
++      || header->e_ident[EI_MAG2] != ELFMAG2
++      || header->e_ident[EI_MAG3] != ELFMAG3)
++    {
++      error
++	(_("Not an ELF file - it has the wrong magic bytes at the start\n"));
++      return false;
++    }
++
++  if (! filedata->is_separate)
++    init_dwarf_regnames_by_elf_machine_code (header->e_machine);
++
++  if (do_header)
++    {
++      unsigned i;
++
++      if (filedata->is_separate)
++	printf (_("ELF Header in linked file '%s':\n"), filedata->file_name);
++      else
++	printf (_("ELF Header:\n"));
++      printf (_("  Magic:   "));
++      for (i = 0; i < EI_NIDENT; i++)
++	printf ("%2.2x ", header->e_ident[i]);
++      printf ("\n");
++      printf (_("  Class:                             %s\n"),
++	      get_elf_class (header->e_ident[EI_CLASS]));
++      printf (_("  Data:                              %s\n"),
++	      get_data_encoding (header->e_ident[EI_DATA]));
++      printf (_("  Version:                           %d%s\n"),
++	      header->e_ident[EI_VERSION],
++	      (header->e_ident[EI_VERSION] == EV_CURRENT
++	       ? _(" (current)")
++	       : (header->e_ident[EI_VERSION] != EV_NONE
++		  ? _(" <unknown>")
++		  : "")));
++      printf (_("  OS/ABI:                            %s\n"),
++	      get_osabi_name (filedata, header->e_ident[EI_OSABI]));
++      printf (_("  ABI Version:                       %d\n"),
++	      header->e_ident[EI_ABIVERSION]);
++      printf (_("  Type:                              %s\n"),
++	      get_file_type (filedata));
++      printf (_("  Machine:                           %s\n"),
++	      get_machine_name (header->e_machine));
++      printf (_("  Version:                           0x%lx\n"),
++	      header->e_version);
++
++      printf (_("  Entry point address:               "));
++      print_vma (header->e_entry, PREFIX_HEX);
++      printf (_("\n  Start of program headers:          "));
++      print_vma (header->e_phoff, DEC);
++      printf (_(" (bytes into file)\n  Start of section headers:          "));
++      print_vma (header->e_shoff, DEC);
++      printf (_(" (bytes into file)\n"));
++
++      printf (_("  Flags:                             0x%lx%s\n"),
++	      header->e_flags,
++	      get_machine_flags (filedata, header->e_flags, header->e_machine));
++      printf (_("  Size of this header:               %u (bytes)\n"),
++	      header->e_ehsize);
++      printf (_("  Size of program headers:           %u (bytes)\n"),
++	      header->e_phentsize);
++      printf (_("  Number of program headers:         %u"),
++	      header->e_phnum);
++      if (filedata->section_headers != NULL
++	  && header->e_phnum == PN_XNUM
++	  && filedata->section_headers[0].sh_info != 0)
++	{
++	  header->e_phnum = filedata->section_headers[0].sh_info;
++	  printf (" (%u)", header->e_phnum);
++	}
++      putc ('\n', stdout);
++      printf (_("  Size of section headers:           %u (bytes)\n"),
++	      header->e_shentsize);
++      printf (_("  Number of section headers:         %u"),
++	      header->e_shnum);
++      if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
++	{
++	  header->e_shnum = filedata->section_headers[0].sh_size;
++	  printf (" (%u)", header->e_shnum);
++	}
++      putc ('\n', stdout);
++      printf (_("  Section header string table index: %u"),
++	      header->e_shstrndx);
++      if (filedata->section_headers != NULL
++	  && header->e_shstrndx == (SHN_XINDEX & 0xffff))
++	{
++	  header->e_shstrndx = filedata->section_headers[0].sh_link;
++	  printf (" (%u)", header->e_shstrndx);
++	}
++      if (header->e_shstrndx != SHN_UNDEF
++	  && header->e_shstrndx >= header->e_shnum)
++	{
++	  header->e_shstrndx = SHN_UNDEF;
++	  printf (_(" <corrupt: out of range>"));
++	}
++      putc ('\n', stdout);
++    }
++
++  if (filedata->section_headers != NULL)
++    {
++      if (header->e_phnum == PN_XNUM
++	  && filedata->section_headers[0].sh_info != 0)
++	header->e_phnum = filedata->section_headers[0].sh_info;
++      if (header->e_shnum == SHN_UNDEF)
++	header->e_shnum = filedata->section_headers[0].sh_size;
++      if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
++	header->e_shstrndx = filedata->section_headers[0].sh_link;
++      if (header->e_shstrndx >= header->e_shnum)
++	header->e_shstrndx = SHN_UNDEF;
++    }
++
++  return true;
++}
++
++/* Read in the program headers from FILEDATA and store them in PHEADERS.
++   Returns TRUE upon success, FALSE otherwise.  Loads 32-bit headers.  */
++
++static bool
++get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
++{
++  Elf32_External_Phdr * phdrs;
++  Elf32_External_Phdr * external;
++  Elf_Internal_Phdr *   internal;
++  unsigned int i;
++  unsigned int size = filedata->file_header.e_phentsize;
++  unsigned int num  = filedata->file_header.e_phnum;
++
++  /* PR binutils/17531: Cope with unexpected section header sizes.  */
++  if (size == 0 || num == 0)
++    return false;
++  if (size < sizeof * phdrs)
++    {
++      error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
++      return false;
++    }
++  if (size > sizeof * phdrs)
++    warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
++
++  phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
++                                            size, num, _("program headers"));
++  if (phdrs == NULL)
++    return false;
++
++  for (i = 0, internal = pheaders, external = phdrs;
++       i < filedata->file_header.e_phnum;
++       i++, internal++, external++)
++    {
++      internal->p_type   = BYTE_GET (external->p_type);
++      internal->p_offset = BYTE_GET (external->p_offset);
++      internal->p_vaddr  = BYTE_GET (external->p_vaddr);
++      internal->p_paddr  = BYTE_GET (external->p_paddr);
++      internal->p_filesz = BYTE_GET (external->p_filesz);
++      internal->p_memsz  = BYTE_GET (external->p_memsz);
++      internal->p_flags  = BYTE_GET (external->p_flags);
++      internal->p_align  = BYTE_GET (external->p_align);
++    }
++
++  free (phdrs);
++  return true;
++}
++
++/* Read in the program headers from FILEDATA and store them in PHEADERS.
++   Returns TRUE upon success, FALSE otherwise.  Loads 64-bit headers.  */
++
++static bool
++get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
++{
++  Elf64_External_Phdr * phdrs;
++  Elf64_External_Phdr * external;
++  Elf_Internal_Phdr *   internal;
++  unsigned int i;
++  unsigned int size = filedata->file_header.e_phentsize;
++  unsigned int num  = filedata->file_header.e_phnum;
++
++  /* PR binutils/17531: Cope with unexpected section header sizes.  */
++  if (size == 0 || num == 0)
++    return false;
++  if (size < sizeof * phdrs)
++    {
++      error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
++      return false;
++    }
++  if (size > sizeof * phdrs)
++    warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
++
++  phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
++                                            size, num, _("program headers"));
++  if (!phdrs)
++    return false;
++
++  for (i = 0, internal = pheaders, external = phdrs;
++       i < filedata->file_header.e_phnum;
++       i++, internal++, external++)
++    {
++      internal->p_type   = BYTE_GET (external->p_type);
++      internal->p_flags  = BYTE_GET (external->p_flags);
++      internal->p_offset = BYTE_GET (external->p_offset);
++      internal->p_vaddr  = BYTE_GET (external->p_vaddr);
++      internal->p_paddr  = BYTE_GET (external->p_paddr);
++      internal->p_filesz = BYTE_GET (external->p_filesz);
++      internal->p_memsz  = BYTE_GET (external->p_memsz);
++      internal->p_align  = BYTE_GET (external->p_align);
++    }
++
++  free (phdrs);
++  return true;
++}
++
++/* Returns TRUE if the program headers were read into `program_headers'.  */
++
++static bool
++get_program_headers (Filedata * filedata)
++{
++  Elf_Internal_Phdr * phdrs;
++
++  /* Check cache of prior read.  */
++  if (filedata->program_headers != NULL)
++    return true;
++
++  /* Be kind to memory checkers by looking for
++     e_phnum values which we know must be invalid.  */
++  if (filedata->file_header.e_phnum
++      * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
++      >= filedata->file_size)
++    {
++      error (_("Too many program headers - %#x - the file is not that big\n"),
++	     filedata->file_header.e_phnum);
++      return false;
++    }
++
++  phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
++					 sizeof (Elf_Internal_Phdr));
++  if (phdrs == NULL)
++    {
++      error (_("Out of memory reading %u program headers\n"),
++	     filedata->file_header.e_phnum);
++      return false;
++    }
++
++  if (is_32bit_elf
++      ? get_32bit_program_headers (filedata, phdrs)
++      : get_64bit_program_headers (filedata, phdrs))
++    {
++      filedata->program_headers = phdrs;
++      return true;
++    }
++
++  free (phdrs);
++  return false;
++}
++
++/* Print program header info and locate dynamic section.  */
++
++static void
++process_program_headers (Filedata * filedata)
++{
++  Elf_Internal_Phdr * segment;
++  unsigned int i;
++  Elf_Internal_Phdr * previous_load = NULL;
++
++  if (filedata->file_header.e_phnum == 0)
++    {
++      /* PR binutils/12467.  */
++      if (filedata->file_header.e_phoff != 0)
++	warn (_("possibly corrupt ELF header - it has a non-zero program"
++		" header offset, but no program headers\n"));
++      else if (do_segments)
++	{
++	  if (filedata->is_separate)
++	    printf (_("\nThere are no program headers in linked file '%s'.\n"),
++		    filedata->file_name);
++	  else
++	    printf (_("\nThere are no program headers in this file.\n"));
++	}
++      goto no_headers;
++    }
++
++  if (do_segments && !do_header)
++    {
++      if (filedata->is_separate)
++	printf ("\nIn linked file '%s' the ELF file type is %s\n",
++		filedata->file_name, get_file_type (filedata));
++      else
++	printf (_("\nElf file type is %s\n"), get_file_type (filedata));
++      printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
++      printf (ngettext ("There is %d program header, starting at offset %s\n",
++			"There are %d program headers, starting at offset %s\n",
++			filedata->file_header.e_phnum),
++	      filedata->file_header.e_phnum,
++	      bfd_vmatoa ("u", filedata->file_header.e_phoff));
++    }
++
++  if (! get_program_headers (filedata))
++    goto no_headers;
++
++  if (do_segments)
++    {
++      if (filedata->file_header.e_phnum > 1)
++	printf (_("\nProgram Headers:\n"));
++      else
++	printf (_("\nProgram Headers:\n"));
++
++      if (is_32bit_elf)
++	printf
++	  (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
++      else if (do_wide)
++	printf
++	  (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
++      else
++	{
++	  printf
++	    (_("  Type           Offset             VirtAddr           PhysAddr\n"));
++	  printf
++	    (_("                 FileSiz            MemSiz              Flags  Align\n"));
++	}
++    }
++
++  unsigned long dynamic_addr = 0;
++  bfd_size_type dynamic_size = 0;
++  for (i = 0, segment = filedata->program_headers;
++       i < filedata->file_header.e_phnum;
++       i++, segment++)
++    {
++      if (do_segments)
++	{
++	  printf ("  %-14.14s ", get_segment_type (filedata, segment->p_type));
++
++	  if (is_32bit_elf)
++	    {
++	      printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
++	      printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
++	      printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
++	      printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
++	      printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
++	      printf ("%c%c%c ",
++		      (segment->p_flags & PF_R ? 'R' : ' '),
++		      (segment->p_flags & PF_W ? 'W' : ' '),
++		      (segment->p_flags & PF_X ? 'E' : ' '));
++	      printf ("%#lx", (unsigned long) segment->p_align);
++	    }
++	  else if (do_wide)
++	    {
++	      if ((unsigned long) segment->p_offset == segment->p_offset)
++		printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
++	      else
++		{
++		  print_vma (segment->p_offset, FULL_HEX);
++		  putchar (' ');
++		}
++
++	      print_vma (segment->p_vaddr, FULL_HEX);
++	      putchar (' ');
++	      print_vma (segment->p_paddr, FULL_HEX);
++	      putchar (' ');
++
++	      if ((unsigned long) segment->p_filesz == segment->p_filesz)
++		printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
++	      else
++		{
++		  print_vma (segment->p_filesz, FULL_HEX);
++		  putchar (' ');
++		}
++
++	      if ((unsigned long) segment->p_memsz == segment->p_memsz)
++		printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
++	      else
++		{
++		  print_vma (segment->p_memsz, FULL_HEX);
++		}
++
++	      printf (" %c%c%c ",
++		      (segment->p_flags & PF_R ? 'R' : ' '),
++		      (segment->p_flags & PF_W ? 'W' : ' '),
++		      (segment->p_flags & PF_X ? 'E' : ' '));
++
++	      if ((unsigned long) segment->p_align == segment->p_align)
++		printf ("%#lx", (unsigned long) segment->p_align);
++	      else
++		{
++		  print_vma (segment->p_align, PREFIX_HEX);
++		}
++	    }
++	  else
++	    {
++	      print_vma (segment->p_offset, FULL_HEX);
++	      putchar (' ');
++	      print_vma (segment->p_vaddr, FULL_HEX);
++	      putchar (' ');
++	      print_vma (segment->p_paddr, FULL_HEX);
++	      printf ("\n                 ");
++	      print_vma (segment->p_filesz, FULL_HEX);
++	      putchar (' ');
++	      print_vma (segment->p_memsz, FULL_HEX);
++	      printf ("  %c%c%c    ",
++		      (segment->p_flags & PF_R ? 'R' : ' '),
++		      (segment->p_flags & PF_W ? 'W' : ' '),
++		      (segment->p_flags & PF_X ? 'E' : ' '));
++	      print_vma (segment->p_align, PREFIX_HEX);
++	    }
++
++	  putc ('\n', stdout);
++	}
++
++      switch (segment->p_type)
++	{
++	case PT_LOAD:
++#if 0 /* Do not warn about out of order PT_LOAD segments.  Although officially
++	 required by the ELF standard, several programs, including the Linux
++	 kernel, make use of non-ordered segments.  */
++	  if (previous_load
++	      && previous_load->p_vaddr > segment->p_vaddr)
++	    error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
++#endif
++	  if (segment->p_memsz < segment->p_filesz)
++	    error (_("the segment's file size is larger than its memory size\n"));
++	  previous_load = segment;
++	  break;
++
++	case PT_PHDR:
++	  /* PR 20815 - Verify that the program header is loaded into memory.  */
++	  if (i > 0 && previous_load != NULL)
++	    error (_("the PHDR segment must occur before any LOAD segment\n"));
++	  if (filedata->file_header.e_machine != EM_PARISC)
++	    {
++	      unsigned int j;
++
++	      for (j = 1; j < filedata->file_header.e_phnum; j++)
++		{
++		  Elf_Internal_Phdr *load = filedata->program_headers + j;
++		  if (load->p_type == PT_LOAD
++		      && load->p_offset <= segment->p_offset
++		      && (load->p_offset + load->p_filesz
++			  >= segment->p_offset + segment->p_filesz)
++		      && load->p_vaddr <= segment->p_vaddr
++		      && (load->p_vaddr + load->p_filesz
++			  >= segment->p_vaddr + segment->p_filesz))
++		    break;
++		}
++	      if (j == filedata->file_header.e_phnum)
++		error (_("the PHDR segment is not covered by a LOAD segment\n"));
++	    }
++	  break;
++
++	case PT_DYNAMIC:
++	  if (dynamic_addr)
++	    error (_("more than one dynamic segment\n"));
++
++	  /* By default, assume that the .dynamic section is the first
++	     section in the DYNAMIC segment.  */
++	  dynamic_addr = segment->p_offset;
++	  dynamic_size = segment->p_filesz;
++
++	  /* Try to locate the .dynamic section. If there is
++	     a section header table, we can easily locate it.  */
++	  if (filedata->section_headers != NULL)
++	    {
++	      Elf_Internal_Shdr * sec;
++
++	      sec = find_section (filedata, ".dynamic");
++	      if (sec == NULL || sec->sh_size == 0)
++		{
++		  /* A corresponding .dynamic section is expected, but on
++		     IA-64/OpenVMS it is OK for it to be missing.  */
++		  if (!is_ia64_vms (filedata))
++		    error (_("no .dynamic section in the dynamic segment\n"));
++		  break;
++		}
++
++	      if (sec->sh_type == SHT_NOBITS)
++		{
++		  dynamic_addr = 0;
++		  dynamic_size = 0;
++		  break;
++		}
++
++	      dynamic_addr = sec->sh_offset;
++	      dynamic_size = sec->sh_size;
++
++	      /* The PT_DYNAMIC segment, which is used by the run-time
++		 loader,  should exactly match the .dynamic section.  */
++	      if (do_checks
++		  && (dynamic_addr != segment->p_offset
++		      || dynamic_size != segment->p_filesz))
++		warn (_("\
++the .dynamic section is not the same as the dynamic segment\n"));
++	    }
++
++	  /* PR binutils/17512: Avoid corrupt dynamic section info in the
++	     segment.  Check this after matching against the section headers
++	     so we don't warn on debuginfo file (which have NOBITS .dynamic
++	     sections).  */
++	  if (dynamic_addr > filedata->file_size
++	      || (dynamic_size > filedata->file_size - dynamic_addr))
++	    {
++	      error (_("the dynamic segment offset + size exceeds the size of the file\n"));
++	      dynamic_addr = 0;
++	      dynamic_size = 0;
++	    }
++	  break;
++
++	case PT_INTERP:
++	  if (segment->p_offset >= filedata->file_size
++	      || segment->p_filesz > filedata->file_size - segment->p_offset
++	      || segment->p_filesz - 1 >= (size_t) -2
++	      || fseek (filedata->handle,
++			filedata->archive_file_offset + (long) segment->p_offset,
++			SEEK_SET))
++	    error (_("Unable to find program interpreter name\n"));
++	  else
++	    {
++	      size_t len = segment->p_filesz;
++	      free (filedata->program_interpreter);
++	      filedata->program_interpreter = xmalloc (len + 1);
++	      len = fread (filedata->program_interpreter, 1, len,
++			   filedata->handle);
++	      filedata->program_interpreter[len] = 0;
++
++	      if (do_segments)
++		printf (_("      [Requesting program interpreter: %s]\n"),
++		    filedata->program_interpreter);
++	    }
++	  break;
++	}
++    }
++
++  if (do_segments
++      && filedata->section_headers != NULL
++      && filedata->string_table != NULL)
++    {
++      printf (_("\n Section to Segment mapping:\n"));
++      printf (_("  Segment Sections...\n"));
++
++      for (i = 0; i < filedata->file_header.e_phnum; i++)
++	{
++	  unsigned int j;
++	  Elf_Internal_Shdr * section;
++
++	  segment = filedata->program_headers + i;
++	  section = filedata->section_headers + 1;
++
++	  printf ("   %2.2d     ", i);
++
++	  for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
++	    {
++	      if (!ELF_TBSS_SPECIAL (section, segment)
++		  && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
++		printf ("%s ", printable_section_name (filedata, section));
++	    }
++
++	  putc ('\n',stdout);
++	}
++    }
++
++  filedata->dynamic_addr = dynamic_addr;
++  filedata->dynamic_size = dynamic_size ? dynamic_size : 1;
++  return;
++
++ no_headers:
++  filedata->dynamic_addr = 0;
++  filedata->dynamic_size = 1;
++}
++
++
++/* Find the file offset corresponding to VMA by using the program headers.  */
++
++static long
++offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
++{
++  Elf_Internal_Phdr * seg;
++
++  if (! get_program_headers (filedata))
++    {
++      warn (_("Cannot interpret virtual addresses without program headers.\n"));
++      return (long) vma;
++    }
++
++  for (seg = filedata->program_headers;
++       seg < filedata->program_headers + filedata->file_header.e_phnum;
++       ++seg)
++    {
++      if (seg->p_type != PT_LOAD)
++	continue;
++
++      if (vma >= (seg->p_vaddr & -seg->p_align)
++	  && vma + size <= seg->p_vaddr + seg->p_filesz)
++	return vma - seg->p_vaddr + seg->p_offset;
++    }
++
++  warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
++	(unsigned long) vma);
++  return (long) vma;
++}
++
++
++/* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
++   If PROBE is true, this is just a probe and we do not generate any error
++   messages if the load fails.  */
++
++static bool
++get_32bit_section_headers (Filedata * filedata, bool probe)
++{
++  Elf32_External_Shdr * shdrs;
++  Elf_Internal_Shdr *   internal;
++  unsigned int          i;
++  unsigned int          size = filedata->file_header.e_shentsize;
++  unsigned int          num = probe ? 1 : filedata->file_header.e_shnum;
++
++  /* PR binutils/17531: Cope with unexpected section header sizes.  */
++  if (size == 0 || num == 0)
++    return false;
++  if (size < sizeof * shdrs)
++    {
++      if (! probe)
++	error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
++      return false;
++    }
++  if (!probe && size > sizeof * shdrs)
++    warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
++
++  shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
++                                            size, num,
++					    probe ? NULL : _("section headers"));
++  if (shdrs == NULL)
++    return false;
++
++  filedata->section_headers = (Elf_Internal_Shdr *)
++    cmalloc (num, sizeof (Elf_Internal_Shdr));
++  if (filedata->section_headers == NULL)
++    {
++      if (!probe)
++	error (_("Out of memory reading %u section headers\n"), num);
++      free (shdrs);
++      return false;
++    }
++
++  for (i = 0, internal = filedata->section_headers;
++       i < num;
++       i++, internal++)
++    {
++      internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
++      internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
++      internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
++      internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
++      internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
++      internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
++      internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
++      internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
++      internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
++      internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
++      if (!probe && internal->sh_link > num)
++	warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
++      if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
++	warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
++    }
++
++  free (shdrs);
++  return true;
++}
++
++/* Like get_32bit_section_headers, except that it fetches 64-bit headers.  */
++
++static bool
++get_64bit_section_headers (Filedata * filedata, bool probe)
++{
++  Elf64_External_Shdr *  shdrs;
++  Elf_Internal_Shdr *    internal;
++  unsigned int           i;
++  unsigned int           size = filedata->file_header.e_shentsize;
++  unsigned int           num = probe ? 1 : filedata->file_header.e_shnum;
++
++  /* PR binutils/17531: Cope with unexpected section header sizes.  */
++  if (size == 0 || num == 0)
++    return false;
++
++  if (size < sizeof * shdrs)
++    {
++      if (! probe)
++	error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
++      return false;
++    }
++
++  if (! probe && size > sizeof * shdrs)
++    warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
++
++  shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
++					    filedata->file_header.e_shoff,
++                                            size, num,
++					    probe ? NULL : _("section headers"));
++  if (shdrs == NULL)
++    return false;
++
++  filedata->section_headers = (Elf_Internal_Shdr *)
++    cmalloc (num, sizeof (Elf_Internal_Shdr));
++  if (filedata->section_headers == NULL)
++    {
++      if (! probe)
++	error (_("Out of memory reading %u section headers\n"), num);
++      free (shdrs);
++      return false;
++    }
++
++  for (i = 0, internal = filedata->section_headers;
++       i < num;
++       i++, internal++)
++    {
++      internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
++      internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
++      internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
++      internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
++      internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
++      internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
++      internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
++      internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
++      internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
++      internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
++      if (!probe && internal->sh_link > num)
++	warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
++      if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
++	warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
++    }
++
++  free (shdrs);
++  return true;
++}
++
++static bool
++get_section_headers (Filedata *filedata, bool probe)
++{
++  if (filedata->section_headers != NULL)
++    return true;
++
++  if (is_32bit_elf)
++    return get_32bit_section_headers (filedata, probe);
++  else
++    return get_64bit_section_headers (filedata, probe);
++}
++
++static Elf_Internal_Sym *
++get_32bit_elf_symbols (Filedata *           filedata,
++		       Elf_Internal_Shdr *  section,
++		       unsigned long *      num_syms_return)
++{
++  unsigned long number = 0;
++  Elf32_External_Sym * esyms = NULL;
++  Elf_External_Sym_Shndx * shndx = NULL;
++  Elf_Internal_Sym * isyms = NULL;
++  Elf_Internal_Sym * psym;
++  unsigned int j;
++  elf_section_list * entry;
++
++  if (section->sh_size == 0)
++    {
++      if (num_syms_return != NULL)
++	* num_syms_return = 0;
++      return NULL;
++    }
++
++  /* Run some sanity checks first.  */
++  if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
++    {
++      error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
++	     printable_section_name (filedata, section),
++	     (unsigned long) section->sh_entsize);
++      goto exit_point;
++    }
++
++  if (section->sh_size > filedata->file_size)
++    {
++      error (_("Section %s has an invalid sh_size of 0x%lx\n"),
++	     printable_section_name (filedata, section),
++	     (unsigned long) section->sh_size);
++      goto exit_point;
++    }
++
++  number = section->sh_size / section->sh_entsize;
++
++  if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
++    {
++      error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
++	     (unsigned long) section->sh_size,
++	     printable_section_name (filedata, section),
++	     (unsigned long) section->sh_entsize);
++      goto exit_point;
++    }
++
++  esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
++                                           section->sh_size, _("symbols"));
++  if (esyms == NULL)
++    goto exit_point;
++
++  shndx = NULL;
++  for (entry = filedata->symtab_shndx_list; entry != NULL; entry = entry->next)
++    {
++      if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
++	continue;
++
++      if (shndx != NULL)
++	{
++	  error (_("Multiple symbol table index sections associated with the same symbol section\n"));
++	  free (shndx);
++	}
++
++      shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
++						   entry->hdr->sh_offset,
++						   1, entry->hdr->sh_size,
++						   _("symbol table section indices"));
++      if (shndx == NULL)
++	goto exit_point;
++
++      /* PR17531: file: heap-buffer-overflow */
++      if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
++	{
++	  error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
++		 printable_section_name (filedata, entry->hdr),
++		 (unsigned long) entry->hdr->sh_size,
++		 (unsigned long) section->sh_size);
++	  goto exit_point;
++	}
++    }
++
++  isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
++
++  if (isyms == NULL)
++    {
++      error (_("Out of memory reading %lu symbols\n"),
++	     (unsigned long) number);
++      goto exit_point;
++    }
++
++  for (j = 0, psym = isyms; j < number; j++, psym++)
++    {
++      psym->st_name  = BYTE_GET (esyms[j].st_name);
++      psym->st_value = BYTE_GET (esyms[j].st_value);
++      psym->st_size  = BYTE_GET (esyms[j].st_size);
++      psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
++      if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
++	psym->st_shndx
++	  = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
++      else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
++	psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
++      psym->st_info  = BYTE_GET (esyms[j].st_info);
++      psym->st_other = BYTE_GET (esyms[j].st_other);
++    }
++
++ exit_point:
++  free (shndx);
++  free (esyms);
++
++  if (num_syms_return != NULL)
++    * num_syms_return = isyms == NULL ? 0 : number;
++
++  return isyms;
++}
++
++static Elf_Internal_Sym *
++get_64bit_elf_symbols (Filedata *           filedata,
++		       Elf_Internal_Shdr *  section,
++		       unsigned long *      num_syms_return)
++{
++  unsigned long number = 0;
++  Elf64_External_Sym * esyms = NULL;
++  Elf_External_Sym_Shndx * shndx = NULL;
++  Elf_Internal_Sym * isyms = NULL;
++  Elf_Internal_Sym * psym;
++  unsigned int j;
++  elf_section_list * entry;
++
++  if (section->sh_size == 0)
++    {
++      if (num_syms_return != NULL)
++	* num_syms_return = 0;
++      return NULL;
++    }
++
++  /* Run some sanity checks first.  */
++  if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
++    {
++      error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
++	     printable_section_name (filedata, section),
++	     (unsigned long) section->sh_entsize);
++      goto exit_point;
++    }
++
++  if (section->sh_size > filedata->file_size)
++    {
++      error (_("Section %s has an invalid sh_size of 0x%lx\n"),
++	     printable_section_name (filedata, section),
++	     (unsigned long) section->sh_size);
++      goto exit_point;
++    }
++
++  number = section->sh_size / section->sh_entsize;
++
++  if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
++    {
++      error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
++	     (unsigned long) section->sh_size,
++	     printable_section_name (filedata, section),
++	     (unsigned long) section->sh_entsize);
++      goto exit_point;
++    }
++
++  esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
++                                           section->sh_size, _("symbols"));
++  if (!esyms)
++    goto exit_point;
++
++  shndx = NULL;
++  for (entry = filedata->symtab_shndx_list; entry != NULL; entry = entry->next)
++    {
++      if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
++	continue;
++
++      if (shndx != NULL)
++	{
++	  error (_("Multiple symbol table index sections associated with the same symbol section\n"));
++	  free (shndx);
++	}
++
++      shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
++						   entry->hdr->sh_offset,
++						   1, entry->hdr->sh_size,
++						   _("symbol table section indices"));
++      if (shndx == NULL)
++	goto exit_point;
++
++      /* PR17531: file: heap-buffer-overflow */
++      if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
++	{
++	  error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
++		 printable_section_name (filedata, entry->hdr),
++		 (unsigned long) entry->hdr->sh_size,
++		 (unsigned long) section->sh_size);
++	  goto exit_point;
++	}
++    }
++
++  isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
++
++  if (isyms == NULL)
++    {
++      error (_("Out of memory reading %lu symbols\n"),
++	     (unsigned long) number);
++      goto exit_point;
++    }
++
++  for (j = 0, psym = isyms; j < number; j++, psym++)
++    {
++      psym->st_name  = BYTE_GET (esyms[j].st_name);
++      psym->st_info  = BYTE_GET (esyms[j].st_info);
++      psym->st_other = BYTE_GET (esyms[j].st_other);
++      psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
++
++      if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
++	psym->st_shndx
++	  = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
++      else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
++	psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
++
++      psym->st_value = BYTE_GET (esyms[j].st_value);
++      psym->st_size  = BYTE_GET (esyms[j].st_size);
++    }
++
++ exit_point:
++  free (shndx);
++  free (esyms);
++
++  if (num_syms_return != NULL)
++    * num_syms_return = isyms == NULL ? 0 : number;
++
++  return isyms;
++}
++
++static Elf_Internal_Sym *
++get_elf_symbols (Filedata *filedata,
++		 Elf_Internal_Shdr *section,
++		 unsigned long *num_syms_return)
++{
++  if (is_32bit_elf)
++    return get_32bit_elf_symbols (filedata, section, num_syms_return);
++  else
++    return get_64bit_elf_symbols (filedata, section, num_syms_return);
++}
++
++static const char *
++get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
++{
++  static char buff[1024];
++  char * p = buff;
++  unsigned int field_size = is_32bit_elf ? 8 : 16;
++  signed int sindex;
++  unsigned int size = sizeof (buff) - (field_size + 4 + 1);
++  bfd_vma os_flags = 0;
++  bfd_vma proc_flags = 0;
++  bfd_vma unknown_flags = 0;
++  static const struct
++    {
++      const char * str;
++      unsigned int len;
++    }
++  flags [] =
++    {
++      /*  0 */ { STRING_COMMA_LEN ("WRITE") },
++      /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
++      /*  2 */ { STRING_COMMA_LEN ("EXEC") },
++      /*  3 */ { STRING_COMMA_LEN ("MERGE") },
++      /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
++      /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
++      /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
++      /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
++      /*  8 */ { STRING_COMMA_LEN ("GROUP") },
++      /*  9 */ { STRING_COMMA_LEN ("TLS") },
++      /* IA-64 specific.  */
++      /* 10 */ { STRING_COMMA_LEN ("SHORT") },
++      /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
++      /* IA-64 OpenVMS specific.  */
++      /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
++      /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
++      /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
++      /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
++      /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
++      /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
++      /* Generic.  */
++      /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
++      /* SPARC specific.  */
++      /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
++      /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
++      /* ARM specific.  */
++      /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
++      /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
++      /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
++      /* GNU specific.  */
++      /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
++      /* VLE specific.  */
++      /* 25 */ { STRING_COMMA_LEN ("VLE") },
++      /* GNU specific.  */
++      /* 26 */ { STRING_COMMA_LEN ("GNU_RETAIN") },
++    };
++
++  if (do_section_details)
++    {
++      sprintf (buff, "[%*.*lx]: ",
++	       field_size, field_size, (unsigned long) sh_flags);
++      p += field_size + 4;
++    }
++
++  while (sh_flags)
++    {
++      bfd_vma flag;
++
++      flag = sh_flags & - sh_flags;
++      sh_flags &= ~ flag;
++
++      if (do_section_details)
++	{
++	  switch (flag)
++	    {
++	    case SHF_WRITE:		sindex = 0; break;
++	    case SHF_ALLOC:		sindex = 1; break;
++	    case SHF_EXECINSTR:		sindex = 2; break;
++	    case SHF_MERGE:		sindex = 3; break;
++	    case SHF_STRINGS:		sindex = 4; break;
++	    case SHF_INFO_LINK:		sindex = 5; break;
++	    case SHF_LINK_ORDER:	sindex = 6; break;
++	    case SHF_OS_NONCONFORMING:	sindex = 7; break;
++	    case SHF_GROUP:		sindex = 8; break;
++	    case SHF_TLS:		sindex = 9; break;
++	    case SHF_EXCLUDE:		sindex = 18; break;
++	    case SHF_COMPRESSED:	sindex = 20; break;
++
++	    default:
++	      sindex = -1;
++	      switch (filedata->file_header.e_machine)
++		{
++		case EM_IA_64:
++		  if (flag == SHF_IA_64_SHORT)
++		    sindex = 10;
++		  else if (flag == SHF_IA_64_NORECOV)
++		    sindex = 11;
++#ifdef BFD64
++		  else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
++		    switch (flag)
++		      {
++		      case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
++		      case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
++		      case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
++		      case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
++		      case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
++		      case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
++		      default:                        break;
++		      }
++#endif
++		  break;
++
++		case EM_386:
++		case EM_IAMCU:
++		case EM_X86_64:
++		case EM_L1OM:
++		case EM_K1OM:
++		case EM_OLD_SPARCV9:
++		case EM_SPARC32PLUS:
++		case EM_SPARCV9:
++		case EM_SPARC:
++		  if (flag == SHF_ORDERED)
++		    sindex = 19;
++		  break;
++
++		case EM_ARM:
++		  switch (flag)
++		    {
++		    case SHF_ENTRYSECT: sindex = 21; break;
++		    case SHF_ARM_PURECODE: sindex = 22; break;
++		    case SHF_COMDEF: sindex = 23; break;
++		    default: break;
++		    }
++		  break;
++		case EM_PPC:
++		  if (flag == SHF_PPC_VLE)
++		    sindex = 25;
++		  break;
++		default:
++		  break;
++		}
++
++	      switch (filedata->file_header.e_ident[EI_OSABI])
++		{
++		case ELFOSABI_GNU:
++		case ELFOSABI_FREEBSD:
++		  if (flag == SHF_GNU_RETAIN)
++		    sindex = 26;
++		  /* Fall through */
++		case ELFOSABI_NONE:
++		  if (flag == SHF_GNU_MBIND)
++		    /* We should not recognize SHF_GNU_MBIND for
++		       ELFOSABI_NONE, but binutils as of 2019-07-23 did
++		       not set the EI_OSABI header byte.  */
++		    sindex = 24;
++		  break;
++		default:
++		  break;
++		}
++	      break;
++	    }
++
++	  if (sindex != -1)
++	    {
++	      if (p != buff + field_size + 4)
++		{
++		  if (size < (10 + 2))
++		    {
++		      warn (_("Internal error: not enough buffer room for section flag info"));
++		      return _("<unknown>");
++		    }
++		  size -= 2;
++		  *p++ = ',';
++		  *p++ = ' ';
++		}
++
++	      size -= flags [sindex].len;
++	      p = stpcpy (p, flags [sindex].str);
++	    }
++	  else if (flag & SHF_MASKOS)
++	    os_flags |= flag;
++	  else if (flag & SHF_MASKPROC)
++	    proc_flags |= flag;
++	  else
++	    unknown_flags |= flag;
++	}
++      else
++	{
++	  switch (flag)
++	    {
++	    case SHF_WRITE:		*p = 'W'; break;
++	    case SHF_ALLOC:		*p = 'A'; break;
++	    case SHF_EXECINSTR:		*p = 'X'; break;
++	    case SHF_MERGE:		*p = 'M'; break;
++	    case SHF_STRINGS:		*p = 'S'; break;
++	    case SHF_INFO_LINK:		*p = 'I'; break;
++	    case SHF_LINK_ORDER:	*p = 'L'; break;
++	    case SHF_OS_NONCONFORMING:	*p = 'O'; break;
++	    case SHF_GROUP:		*p = 'G'; break;
++	    case SHF_TLS:		*p = 'T'; break;
++	    case SHF_EXCLUDE:		*p = 'E'; break;
++	    case SHF_COMPRESSED:	*p = 'C'; break;
++
++	    default:
++	      if ((filedata->file_header.e_machine == EM_X86_64
++		   || filedata->file_header.e_machine == EM_L1OM
++		   || filedata->file_header.e_machine == EM_K1OM)
++		  && flag == SHF_X86_64_LARGE)
++		*p = 'l';
++	      else if (filedata->file_header.e_machine == EM_ARM
++		       && flag == SHF_ARM_PURECODE)
++		*p = 'y';
++	      else if (filedata->file_header.e_machine == EM_PPC
++		       && flag == SHF_PPC_VLE)
++		*p = 'v';
++	      else if (flag & SHF_MASKOS)
++		{
++		  switch (filedata->file_header.e_ident[EI_OSABI])
++		    {
++		    case ELFOSABI_GNU:
++		    case ELFOSABI_FREEBSD:
++		      if (flag == SHF_GNU_RETAIN)
++			{
++			  *p = 'R';
++			  break;
++			}
++		      /* Fall through */
++		    case ELFOSABI_NONE:
++		      if (flag == SHF_GNU_MBIND)
++			{
++			  /* We should not recognize SHF_GNU_MBIND for
++			     ELFOSABI_NONE, but binutils as of 2019-07-23 did
++			     not set the EI_OSABI header byte.  */
++			  *p = 'D';
++			  break;
++			}
++		      /* Fall through */
++		    default:
++		      *p = 'o';
++		      sh_flags &= ~SHF_MASKOS;
++		      break;
++		    }
++		}
++	      else if (flag & SHF_MASKPROC)
++		{
++		  *p = 'p';
++		  sh_flags &= ~ SHF_MASKPROC;
++		}
++	      else
++		*p = 'x';
++	      break;
++	    }
++	  p++;
++	}
++    }
++
++  if (do_section_details)
++    {
++      if (os_flags)
++	{
++	  size -= 5 + field_size;
++	  if (p != buff + field_size + 4)
++	    {
++	      if (size < (2 + 1))
++		{
++		  warn (_("Internal error: not enough buffer room for section flag info"));
++		  return _("<unknown>");
++		}
++	      size -= 2;
++	      *p++ = ',';
++	      *p++ = ' ';
++	    }
++	  sprintf (p, "OS (%*.*lx)", field_size, field_size,
++		   (unsigned long) os_flags);
++	  p += 5 + field_size;
++	}
++      if (proc_flags)
++	{
++	  size -= 7 + field_size;
++	  if (p != buff + field_size + 4)
++	    {
++	      if (size < (2 + 1))
++		{
++		  warn (_("Internal error: not enough buffer room for section flag info"));
++		  return _("<unknown>");
++		}
++	      size -= 2;
++	      *p++ = ',';
++	      *p++ = ' ';
++	    }
++	  sprintf (p, "PROC (%*.*lx)", field_size, field_size,
++		   (unsigned long) proc_flags);
++	  p += 7 + field_size;
++	}
++      if (unknown_flags)
++	{
++	  size -= 10 + field_size;
++	  if (p != buff + field_size + 4)
++	    {
++	      if (size < (2 + 1))
++		{
++		  warn (_("Internal error: not enough buffer room for section flag info"));
++		  return _("<unknown>");
++		}
++	      size -= 2;
++	      *p++ = ',';
++	      *p++ = ' ';
++	    }
++	  sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
++		   (unsigned long) unknown_flags);
++	  p += 10 + field_size;
++	}
++    }
++
++  *p = '\0';
++  return buff;
++}
++
++static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
++get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
++{
++  if (is_32bit_elf)
++    {
++      Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
++
++      if (size < sizeof (* echdr))
++	{
++	  error (_("Compressed section is too small even for a compression header\n"));
++	  return 0;
++	}
++
++      chdr->ch_type = BYTE_GET (echdr->ch_type);
++      chdr->ch_size = BYTE_GET (echdr->ch_size);
++      chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
++      return sizeof (*echdr);
++    }
++  else
++    {
++      Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
++
++      if (size < sizeof (* echdr))
++	{
++	  error (_("Compressed section is too small even for a compression header\n"));
++	  return 0;
++	}
++
++      chdr->ch_type = BYTE_GET (echdr->ch_type);
++      chdr->ch_size = BYTE_GET (echdr->ch_size);
++      chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
++      return sizeof (*echdr);
++    }
++}
++
++static bool
++process_section_headers (Filedata * filedata)
++{
++  Elf_Internal_Shdr * section;
++  unsigned int i;
++
++  if (filedata->file_header.e_shnum == 0)
++    {
++      /* PR binutils/12467.  */
++      if (filedata->file_header.e_shoff != 0)
++	{
++	  warn (_("possibly corrupt ELF file header - it has a non-zero"
++		  " section header offset, but no section headers\n"));
++	  return false;
++	}
++      else if (do_sections)
++	printf (_("\nThere are no sections in this file.\n"));
++
++      return true;
++    }
++
++  if (do_sections && !do_header)
++    {
++      if (filedata->is_separate && process_links)
++	printf (_("In linked file '%s': "), filedata->file_name);
++      if (! filedata->is_separate || process_links)
++	printf (ngettext ("There is %d section header, "
++			  "starting at offset 0x%lx:\n",
++			  "There are %d section headers, "
++			  "starting at offset 0x%lx:\n",
++			  filedata->file_header.e_shnum),
++		filedata->file_header.e_shnum,
++		(unsigned long) filedata->file_header.e_shoff);
++    }
++
++  if (!get_section_headers (filedata, false))
++    return false;
++
++  /* Read in the string table, so that we have names to display.  */
++  if (filedata->file_header.e_shstrndx != SHN_UNDEF
++       && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
++    {
++      section = filedata->section_headers + filedata->file_header.e_shstrndx;
++
++      if (section->sh_size != 0)
++	{
++	  filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
++						      1, section->sh_size,
++						      _("string table"));
++
++	  filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
++	}
++    }
++
++  /* Scan the sections for the dynamic symbol table
++     and dynamic string table and debug sections.  */
++  eh_addr_size = is_32bit_elf ? 4 : 8;
++  switch (filedata->file_header.e_machine)
++    {
++    case EM_MIPS:
++    case EM_MIPS_RS3_LE:
++      /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
++	 FDE addresses.  However, the ABI also has a semi-official ILP32
++	 variant for which the normal FDE address size rules apply.
++
++	 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
++	 section, where XX is the size of longs in bits.  Unfortunately,
++	 earlier compilers provided no way of distinguishing ILP32 objects
++	 from LP64 objects, so if there's any doubt, we should assume that
++	 the official LP64 form is being used.  */
++      if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
++	  && find_section (filedata, ".gcc_compiled_long32") == NULL)
++	eh_addr_size = 8;
++      break;
++
++    case EM_H8_300:
++    case EM_H8_300H:
++      switch (filedata->file_header.e_flags & EF_H8_MACH)
++	{
++	case E_H8_MACH_H8300:
++	case E_H8_MACH_H8300HN:
++	case E_H8_MACH_H8300SN:
++	case E_H8_MACH_H8300SXN:
++	  eh_addr_size = 2;
++	  break;
++	case E_H8_MACH_H8300H:
++	case E_H8_MACH_H8300S:
++	case E_H8_MACH_H8300SX:
++	  eh_addr_size = 4;
++	  break;
++	}
++      break;
++
++    case EM_M32C_OLD:
++    case EM_M32C:
++      switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
++	{
++	case EF_M32C_CPU_M16C:
++	  eh_addr_size = 2;
++	  break;
++	}
++      break;
++    }
++
++#define CHECK_ENTSIZE_VALUES(section, i, size32, size64)		\
++  do									\
++    {									\
++      bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;	\
++      if (section->sh_entsize != expected_entsize)			\
++	{								\
++	  char buf[40];							\
++	  sprintf_vma (buf, section->sh_entsize);			\
++	  /* Note: coded this way so that there is a single string for  \
++	     translation.  */ \
++	  error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
++	  error (_("(Using the expected size of %u for the rest of this dump)\n"), \
++		   (unsigned) expected_entsize);			\
++	  section->sh_entsize = expected_entsize;			\
++	}								\
++    }									\
++  while (0)
++
++#define CHECK_ENTSIZE(section, i, type)					\
++  CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),	\
++			sizeof (Elf64_External_##type))
++
++  for (i = 0, section = filedata->section_headers;
++       i < filedata->file_header.e_shnum;
++       i++, section++)
++    {
++      char * name = SECTION_NAME_PRINT (section);
++
++      /* Run some sanity checks on the headers and
++	 possibly fill in some file data as well.  */
++      switch (section->sh_type)
++	{
++	case SHT_DYNSYM:
++	  if (filedata->dynamic_symbols != NULL)
++	    {
++	      error (_("File contains multiple dynamic symbol tables\n"));
++	      continue;
++	    }
++
++	  CHECK_ENTSIZE (section, i, Sym);
++	  filedata->dynamic_symbols
++	    = get_elf_symbols (filedata, section, &filedata->num_dynamic_syms);
++	  filedata->dynamic_symtab_section = section;
++	  break;
++
++	case SHT_STRTAB:
++	  if (streq (name, ".dynstr"))
++	    {
++	      if (filedata->dynamic_strings != NULL)
++		{
++		  error (_("File contains multiple dynamic string tables\n"));
++		  continue;
++		}
++
++	      filedata->dynamic_strings
++		= (char *) get_data (NULL, filedata, section->sh_offset,
++				     1, section->sh_size, _("dynamic strings"));
++	      filedata->dynamic_strings_length
++		= filedata->dynamic_strings == NULL ? 0 : section->sh_size;
++	      filedata->dynamic_strtab_section = section;
++	    }
++	  break;
++
++	case SHT_SYMTAB_SHNDX:
++	  {
++	    elf_section_list * entry = xmalloc (sizeof * entry);
++
++	    entry->hdr = section;
++	    entry->next = filedata->symtab_shndx_list;
++	    filedata->symtab_shndx_list = entry;
++	  }
++	  break;
++
++	case SHT_SYMTAB:
++	  CHECK_ENTSIZE (section, i, Sym);
++	  break;
++
++	case SHT_GROUP:
++	  CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
++	  break;
++
++	case SHT_REL:
++	  CHECK_ENTSIZE (section, i, Rel);
++	  if (do_checks && section->sh_size == 0)
++	    warn (_("Section '%s': zero-sized relocation section\n"), name);
++	  break;
++
++	case SHT_RELA:
++	  CHECK_ENTSIZE (section, i, Rela);
++	  if (do_checks && section->sh_size == 0)
++	    warn (_("Section '%s': zero-sized relocation section\n"), name);
++	  break;
++
++	case SHT_NOTE:
++	case SHT_PROGBITS:
++	  /* Having a zero sized section is not illegal according to the
++	     ELF standard, but it might be an indication that something
++	     is wrong.  So issue a warning if we are running in lint mode.  */
++	  if (do_checks && section->sh_size == 0)
++	    warn (_("Section '%s': has a size of zero - is this intended ?\n"), name);
++	  break;
++
++	default:
++	  break;
++	}
++
++      if ((do_debugging || do_debug_info || do_debug_abbrevs
++	   || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
++	   || do_debug_aranges || do_debug_frames || do_debug_macinfo
++	   || do_debug_str || do_debug_str_offsets || do_debug_loc
++	   || do_debug_ranges
++	   || do_debug_addr || do_debug_cu_index || do_debug_links)
++	  && (startswith (name, ".debug_")
++	      || startswith (name, ".zdebug_")))
++	{
++          if (name[1] == 'z')
++            name += sizeof (".zdebug_") - 1;
++          else
++            name += sizeof (".debug_") - 1;
++
++	  if (do_debugging
++	      || (do_debug_info     && startswith (name, "info"))
++	      || (do_debug_info     && startswith (name, "types"))
++	      || (do_debug_abbrevs  && startswith (name, "abbrev"))
++	      || (do_debug_lines    && strcmp (name, "line") == 0)
++	      || (do_debug_lines    && startswith (name, "line."))
++	      || (do_debug_pubnames && startswith (name, "pubnames"))
++	      || (do_debug_pubtypes && startswith (name, "pubtypes"))
++	      || (do_debug_pubnames && startswith (name, "gnu_pubnames"))
++	      || (do_debug_pubtypes && startswith (name, "gnu_pubtypes"))
++	      || (do_debug_aranges  && startswith (name, "aranges"))
++	      || (do_debug_ranges   && startswith (name, "ranges"))
++	      || (do_debug_ranges   && startswith (name, "rnglists"))
++	      || (do_debug_frames   && startswith (name, "frame"))
++	      || (do_debug_macinfo  && startswith (name, "macinfo"))
++	      || (do_debug_macinfo  && startswith (name, "macro"))
++	      || (do_debug_str      && startswith (name, "str"))
++	      || (do_debug_links    && startswith (name, "sup"))
++	      || (do_debug_str_offsets && startswith (name, "str_offsets"))
++	      || (do_debug_loc      && startswith (name, "loc"))
++	      || (do_debug_loc      && startswith (name, "loclists"))
++	      || (do_debug_addr     && startswith (name, "addr"))
++	      || (do_debug_cu_index && startswith (name, "cu_index"))
++	      || (do_debug_cu_index && startswith (name, "tu_index"))
++	      )
++	    request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
++	}
++      /* Linkonce section to be combined with .debug_info at link time.  */
++      else if ((do_debugging || do_debug_info)
++	       && startswith (name, ".gnu.linkonce.wi."))
++	request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
++      else if (do_debug_frames && streq (name, ".eh_frame"))
++	request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
++      else if (do_gdb_index && (streq (name, ".gdb_index")
++				|| streq (name, ".debug_names")))
++	request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
++      /* Trace sections for Itanium VMS.  */
++      else if ((do_debugging || do_trace_info || do_trace_abbrevs
++                || do_trace_aranges)
++	       && startswith (name, ".trace_"))
++	{
++          name += sizeof (".trace_") - 1;
++
++	  if (do_debugging
++	      || (do_trace_info     && streq (name, "info"))
++	      || (do_trace_abbrevs  && streq (name, "abbrev"))
++	      || (do_trace_aranges  && streq (name, "aranges"))
++	      )
++	    request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
++	}
++      else if ((do_debugging || do_debug_links)
++	       && (startswith (name, ".gnu_debuglink")
++		   || startswith (name, ".gnu_debugaltlink")))
++	request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
++    }
++
++  if (! do_sections)
++    return true;
++
++  if (filedata->is_separate && ! process_links)
++    return true;
++
++  if (filedata->is_separate)
++    printf (_("\nSection Headers in linked file '%s':\n"), filedata->file_name);
++  else if (filedata->file_header.e_shnum > 1)
++    printf (_("\nSection Headers:\n"));
++  else
++    printf (_("\nSection Header:\n"));
++
++  if (is_32bit_elf)
++    {
++      if (do_section_details)
++	{
++	  printf (_("  [Nr] Name\n"));
++	  printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
++	}
++      else
++	printf
++	  (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
++    }
++  else if (do_wide)
++    {
++      if (do_section_details)
++	{
++	  printf (_("  [Nr] Name\n"));
++	  printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
++	}
++      else
++	printf
++	  (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
++    }
++  else
++    {
++      if (do_section_details)
++	{
++	  printf (_("  [Nr] Name\n"));
++	  printf (_("       Type              Address          Offset            Link\n"));
++	  printf (_("       Size              EntSize          Info              Align\n"));
++	}
++      else
++	{
++	  printf (_("  [Nr] Name              Type             Address           Offset\n"));
++	  printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
++	}
++    }
++
++  if (do_section_details)
++    printf (_("       Flags\n"));
++
++  for (i = 0, section = filedata->section_headers;
++       i < filedata->file_header.e_shnum;
++       i++, section++)
++    {
++      /* Run some sanity checks on the section header.  */
++
++      /* Check the sh_link field.  */
++      switch (section->sh_type)
++	{
++	case SHT_REL:
++	case SHT_RELA:
++	  if (section->sh_link == 0
++	      && (filedata->file_header.e_type == ET_EXEC
++		  || filedata->file_header.e_type == ET_DYN))
++	    /* A dynamic relocation section where all entries use a
++	       zero symbol index need not specify a symtab section.  */
++	    break;
++	  /* Fall through.  */
++	case SHT_SYMTAB_SHNDX:
++	case SHT_GROUP:
++	case SHT_HASH:
++	case SHT_GNU_HASH:
++	case SHT_GNU_versym:
++	  if (section->sh_link == 0
++	      || section->sh_link >= filedata->file_header.e_shnum
++	      || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
++		  && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
++	    warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
++		  i, section->sh_link);
++	  break;
++
++	case SHT_DYNAMIC:
++	case SHT_SYMTAB:
++	case SHT_DYNSYM:
++	case SHT_GNU_verneed:
++	case SHT_GNU_verdef:
++	case SHT_GNU_LIBLIST:
++	  if (section->sh_link == 0
++	      || section->sh_link >= filedata->file_header.e_shnum
++	      || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
++	    warn (_("[%2u]: Link field (%u) should index a string section.\n"),
++		  i, section->sh_link);
++	  break;
++
++	case SHT_INIT_ARRAY:
++	case SHT_FINI_ARRAY:
++	case SHT_PREINIT_ARRAY:
++	  if (section->sh_type < SHT_LOOS && section->sh_link != 0)
++	    warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
++		  i, section->sh_link);
++	  break;
++
++	default:
++	  /* FIXME: Add support for target specific section types.  */
++#if 0 	  /* Currently we do not check other section types as there are too
++	     many special cases.  Stab sections for example have a type
++	     of SHT_PROGBITS but an sh_link field that links to the .stabstr
++	     section.  */
++	  if (section->sh_type < SHT_LOOS && section->sh_link != 0)
++	    warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
++		  i, section->sh_link);
++#endif
++	  break;
++	}
++
++      /* Check the sh_info field.  */
++      switch (section->sh_type)
++	{
++	case SHT_REL:
++	case SHT_RELA:
++	  if (section->sh_info == 0
++	      && (filedata->file_header.e_type == ET_EXEC
++		  || filedata->file_header.e_type == ET_DYN))
++	    /* Dynamic relocations apply to segments, so they do not
++	       need to specify the section they relocate.  */
++	    break;
++	  if (section->sh_info == 0
++	      || section->sh_info >= filedata->file_header.e_shnum
++	      || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
++		  && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
++		  && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
++		  && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
++		  && filedata->section_headers[section->sh_info].sh_type != SHT_FINI_ARRAY
++		  && filedata->section_headers[section->sh_info].sh_type != SHT_PREINIT_ARRAY
++		  /* FIXME: Are other section types valid ?  */
++		  && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
++	    warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
++		  i, section->sh_info);
++	  break;
++
++	case SHT_DYNAMIC:
++	case SHT_HASH:
++	case SHT_SYMTAB_SHNDX:
++	case SHT_INIT_ARRAY:
++	case SHT_FINI_ARRAY:
++	case SHT_PREINIT_ARRAY:
++	  if (section->sh_info != 0)
++	    warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
++		  i, section->sh_info);
++	  break;
++
++	case SHT_GROUP:
++	case SHT_SYMTAB:
++	case SHT_DYNSYM:
++	  /* A symbol index - we assume that it is valid.  */
++	  break;
++
++	default:
++	  /* FIXME: Add support for target specific section types.  */
++	  if (section->sh_type == SHT_NOBITS)
++	    /* NOBITS section headers with non-zero sh_info fields can be
++	       created when a binary is stripped of everything but its debug
++	       information.  The stripped sections have their headers
++	       preserved but their types set to SHT_NOBITS.  So do not check
++	       this type of section.  */
++	    ;
++	  else if (section->sh_flags & SHF_INFO_LINK)
++	    {
++	      if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
++		warn (_("[%2u]: Expected link to another section in info field"), i);
++	    }
++	  else if (section->sh_type < SHT_LOOS
++		   && (section->sh_flags & SHF_GNU_MBIND) == 0
++		   && section->sh_info != 0)
++	    warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
++		  i, section->sh_info);
++	  break;
++	}
++
++      /* Check the sh_size field.  */
++      if (section->sh_size > filedata->file_size
++	  && section->sh_type != SHT_NOBITS
++	  && section->sh_type != SHT_NULL
++	  && section->sh_type < SHT_LOOS)
++	warn (_("Size of section %u is larger than the entire file!\n"), i);
++
++      printf ("  [%2u] ", i);
++      if (do_section_details)
++	printf ("%s\n      ", printable_section_name (filedata, section));
++      else
++	print_symbol (-17, SECTION_NAME_PRINT (section));
++
++      printf (do_wide ? " %-15s " : " %-15.15s ",
++	      get_section_type_name (filedata, section->sh_type));
++
++      if (is_32bit_elf)
++	{
++	  const char * link_too_big = NULL;
++
++	  print_vma (section->sh_addr, LONG_HEX);
++
++	  printf ( " %6.6lx %6.6lx %2.2lx",
++		   (unsigned long) section->sh_offset,
++		   (unsigned long) section->sh_size,
++		   (unsigned long) section->sh_entsize);
++
++	  if (do_section_details)
++	    fputs ("  ", stdout);
++	  else
++	    printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
++
++	  if (section->sh_link >= filedata->file_header.e_shnum)
++	    {
++	      link_too_big = "";
++	      /* The sh_link value is out of range.  Normally this indicates
++		 an error but it can have special values in Solaris binaries.  */
++	      switch (filedata->file_header.e_machine)
++		{
++		case EM_386:
++		case EM_IAMCU:
++		case EM_X86_64:
++		case EM_L1OM:
++		case EM_K1OM:
++		case EM_OLD_SPARCV9:
++		case EM_SPARC32PLUS:
++		case EM_SPARCV9:
++		case EM_SPARC:
++		  if (section->sh_link == (SHN_BEFORE & 0xffff))
++		    link_too_big = "BEFORE";
++		  else if (section->sh_link == (SHN_AFTER & 0xffff))
++		    link_too_big = "AFTER";
++		  break;
++		default:
++		  break;
++		}
++	    }
++
++	  if (do_section_details)
++	    {
++	      if (link_too_big != NULL && * link_too_big)
++		printf ("<%s> ", link_too_big);
++	      else
++		printf ("%2u ", section->sh_link);
++	      printf ("%3u %2lu\n", section->sh_info,
++		      (unsigned long) section->sh_addralign);
++	    }
++	  else
++	    printf ("%2u %3u %2lu\n",
++		    section->sh_link,
++		    section->sh_info,
++		    (unsigned long) section->sh_addralign);
++
++	  if (link_too_big && ! * link_too_big)
++	    warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
++		  i, section->sh_link);
++	}
++      else if (do_wide)
++	{
++	  print_vma (section->sh_addr, LONG_HEX);
++
++	  if ((long) section->sh_offset == section->sh_offset)
++	    printf (" %6.6lx", (unsigned long) section->sh_offset);
++	  else
++	    {
++	      putchar (' ');
++	      print_vma (section->sh_offset, LONG_HEX);
++	    }
++
++	  if ((unsigned long) section->sh_size == section->sh_size)
++	    printf (" %6.6lx", (unsigned long) section->sh_size);
++	  else
++	    {
++	      putchar (' ');
++	      print_vma (section->sh_size, LONG_HEX);
++	    }
++
++	  if ((unsigned long) section->sh_entsize == section->sh_entsize)
++	    printf (" %2.2lx", (unsigned long) section->sh_entsize);
++	  else
++	    {
++	      putchar (' ');
++	      print_vma (section->sh_entsize, LONG_HEX);
++	    }
++
++	  if (do_section_details)
++	    fputs ("  ", stdout);
++	  else
++	    printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
++
++	  printf ("%2u %3u ", section->sh_link, section->sh_info);
++
++	  if ((unsigned long) section->sh_addralign == section->sh_addralign)
++	    printf ("%2lu\n", (unsigned long) section->sh_addralign);
++	  else
++	    {
++	      print_vma (section->sh_addralign, DEC);
++	      putchar ('\n');
++	    }
++	}
++      else if (do_section_details)
++	{
++	  putchar (' ');
++	  print_vma (section->sh_addr, LONG_HEX);
++	  if ((long) section->sh_offset == section->sh_offset)
++	    printf ("  %16.16lx", (unsigned long) section->sh_offset);
++	  else
++	    {
++	      printf ("  ");
++	      print_vma (section->sh_offset, LONG_HEX);
++	    }
++	  printf ("  %u\n       ", section->sh_link);
++	  print_vma (section->sh_size, LONG_HEX);
++	  putchar (' ');
++	  print_vma (section->sh_entsize, LONG_HEX);
++
++	  printf ("  %-16u  %lu\n",
++		  section->sh_info,
++		  (unsigned long) section->sh_addralign);
++	}
++      else
++	{
++	  putchar (' ');
++	  print_vma (section->sh_addr, LONG_HEX);
++	  if ((long) section->sh_offset == section->sh_offset)
++	    printf ("  %8.8lx", (unsigned long) section->sh_offset);
++	  else
++	    {
++	      printf ("  ");
++	      print_vma (section->sh_offset, LONG_HEX);
++	    }
++	  printf ("\n       ");
++	  print_vma (section->sh_size, LONG_HEX);
++	  printf ("  ");
++	  print_vma (section->sh_entsize, LONG_HEX);
++
++	  printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
++
++	  printf ("     %2u   %3u     %lu\n",
++		  section->sh_link,
++		  section->sh_info,
++		  (unsigned long) section->sh_addralign);
++	}
++
++      if (do_section_details)
++	{
++	  printf ("       %s\n", get_elf_section_flags (filedata, section->sh_flags));
++	  if ((section->sh_flags & SHF_COMPRESSED) != 0)
++	    {
++	      /* Minimum section size is 12 bytes for 32-bit compression
++		 header + 12 bytes for compressed data header.  */
++	      unsigned char buf[24];
++
++	      assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
++	      if (get_data (&buf, filedata, section->sh_offset, 1,
++			    sizeof (buf), _("compression header")))
++		{
++		  Elf_Internal_Chdr chdr;
++
++		  if (get_compression_header (&chdr, buf, sizeof (buf)) == 0)
++		    printf (_("       [<corrupt>]\n"));
++		  else
++		    {
++		      if (chdr.ch_type == ELFCOMPRESS_ZLIB)
++			printf ("       ZLIB, ");
++		      else
++			printf (_("       [<unknown>: 0x%x], "),
++				chdr.ch_type);
++		      print_vma (chdr.ch_size, LONG_HEX);
++		      printf (", %lu\n", (unsigned long) chdr.ch_addralign);
++		    }
++		}
++	    }
++	}
++    }
++
++  if (!do_section_details)
++    {
++      /* The ordering of the letters shown here matches the ordering of the
++	 corresponding SHF_xxx values, and hence the order in which these
++	 letters will be displayed to the user.  */
++      printf (_("Key to Flags:\n\
++  W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
++  L (link order), O (extra OS processing required), G (group), T (TLS),\n\
++  C (compressed), x (unknown), o (OS specific), E (exclude),\n  "));
++      switch (filedata->file_header.e_ident[EI_OSABI])
++	{
++	case ELFOSABI_GNU:
++	case ELFOSABI_FREEBSD:
++	  printf (_("R (retain), "));
++	  /* Fall through */
++	case ELFOSABI_NONE:
++	  printf (_("D (mbind), "));
++	  break;
++	default:
++	  break;
++	}
++      if (filedata->file_header.e_machine == EM_X86_64
++	  || filedata->file_header.e_machine == EM_L1OM
++	  || filedata->file_header.e_machine == EM_K1OM)
++	printf (_("l (large), "));
++      else if (filedata->file_header.e_machine == EM_ARM)
++	printf (_("y (purecode), "));
++      else if (filedata->file_header.e_machine == EM_PPC)
++	printf (_("v (VLE), "));
++      printf ("p (processor specific)\n");
++    }
++
++  return true;
++}
++
++static bool
++get_symtab (Filedata *filedata, Elf_Internal_Shdr *symsec,
++	    Elf_Internal_Sym **symtab, unsigned long *nsyms,
++	    char **strtab, unsigned long *strtablen)
++{
++  *strtab = NULL;
++  *strtablen = 0;
++  *symtab = get_elf_symbols (filedata, symsec, nsyms);
++
++  if (*symtab == NULL)
++    return false;
++
++  if (symsec->sh_link != 0)
++    {
++      Elf_Internal_Shdr *strsec;
++
++      if (symsec->sh_link >= filedata->file_header.e_shnum)
++	{
++	  error (_("Bad sh_link in symbol table section\n"));
++	  free (*symtab);
++	  *symtab = NULL;
++	  *nsyms = 0;
++	  return false;
++	}
++
++      strsec = filedata->section_headers + symsec->sh_link;
++
++      *strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
++				   1, strsec->sh_size, _("string table"));
++      if (*strtab == NULL)
++	{
++	  free (*symtab);
++	  *symtab = NULL;
++	  *nsyms = 0;
++	  return false;
++	}
++      *strtablen = strsec->sh_size;
++    }
++  return true;
++}
++
++static const char *
++get_group_flags (unsigned int flags)
++{
++  static char buff[128];
++
++  if (flags == 0)
++    return "";
++  else if (flags == GRP_COMDAT)
++    return "COMDAT ";
++
++  snprintf (buff, sizeof buff, "[0x%x: %s%s%s]",
++	    flags,
++	    flags & GRP_MASKOS ? _("<OS specific>") : "",
++	    flags & GRP_MASKPROC ? _("<PROC specific>") : "",
++	    (flags & ~(GRP_COMDAT | GRP_MASKOS | GRP_MASKPROC)
++	     ? _("<unknown>") : ""));
++
++  return buff;
++}
++
++static bool
++process_section_groups (Filedata * filedata)
++{
++  Elf_Internal_Shdr * section;
++  unsigned int i;
++  struct group * group;
++  Elf_Internal_Shdr * symtab_sec;
++  Elf_Internal_Shdr * strtab_sec;
++  Elf_Internal_Sym * symtab;
++  unsigned long num_syms;
++  char * strtab;
++  size_t strtab_size;
++
++  /* Don't process section groups unless needed.  */
++  if (!do_unwind && !do_section_groups)
++    return true;
++
++  if (filedata->file_header.e_shnum == 0)
++    {
++      if (do_section_groups)
++	{
++	  if (filedata->is_separate)
++	    printf (_("\nThere are no sections group in linked file '%s'.\n"),
++		    filedata->file_name);
++	  else
++	    printf (_("\nThere are no section groups in this file.\n"));
++	}
++      return true;
++    }
++
++  if (filedata->section_headers == NULL)
++    {
++      error (_("Section headers are not available!\n"));
++      /* PR 13622: This can happen with a corrupt ELF header.  */
++      return false;
++    }
++
++  filedata->section_headers_groups
++    = (struct group **) calloc (filedata->file_header.e_shnum,
++				sizeof (struct group *));
++
++  if (filedata->section_headers_groups == NULL)
++    {
++      error (_("Out of memory reading %u section group headers\n"),
++	     filedata->file_header.e_shnum);
++      return false;
++    }
++
++  /* Scan the sections for the group section.  */
++  filedata->group_count = 0;
++  for (i = 0, section = filedata->section_headers;
++       i < filedata->file_header.e_shnum;
++       i++, section++)
++    if (section->sh_type == SHT_GROUP)
++      filedata->group_count++;
++
++  if (filedata->group_count == 0)
++    {
++      if (do_section_groups)
++	{
++	  if (filedata->is_separate)
++	    printf (_("\nThere are no section groups in linked file '%s'.\n"),
++		    filedata->file_name);
++	  else
++	    printf (_("\nThere are no section groups in this file.\n"));
++	}
++
++      return true;
++    }
++
++  filedata->section_groups = (struct group *) calloc (filedata->group_count,
++						      sizeof (struct group));
++
++  if (filedata->section_groups == NULL)
++    {
++      error (_("Out of memory reading %lu groups\n"),
++	     (unsigned long) filedata->group_count);
++      return false;
++    }
++
++  symtab_sec = NULL;
++  strtab_sec = NULL;
++  symtab = NULL;
++  num_syms = 0;
++  strtab = NULL;
++  strtab_size = 0;
++
++  if (filedata->is_separate)
++    printf (_("Section groups in linked file '%s'\n"), filedata->file_name);
++
++  for (i = 0, section = filedata->section_headers, group = filedata->section_groups;
++       i < filedata->file_header.e_shnum;
++       i++, section++)
++    {
++      if (section->sh_type == SHT_GROUP)
++	{
++	  const char * name = printable_section_name (filedata, section);
++	  const char * group_name;
++	  unsigned char * start;
++	  unsigned char * indices;
++	  unsigned int entry, j, size;
++	  Elf_Internal_Shdr * sec;
++	  Elf_Internal_Sym * sym;
++
++	  /* Get the symbol table.  */
++	  if (section->sh_link >= filedata->file_header.e_shnum
++	      || ((sec = filedata->section_headers + section->sh_link)->sh_type
++		  != SHT_SYMTAB))
++	    {
++	      error (_("Bad sh_link in group section `%s'\n"), name);
++	      continue;
++	    }
++
++	  if (symtab_sec != sec)
++	    {
++	      symtab_sec = sec;
++	      free (symtab);
++	      symtab = get_elf_symbols (filedata, symtab_sec, & num_syms);
++	    }
++
++	  if (symtab == NULL)
++	    {
++	      error (_("Corrupt header in group section `%s'\n"), name);
++	      continue;
++	    }
++
++	  if (section->sh_info >= num_syms)
++	    {
++	      error (_("Bad sh_info in group section `%s'\n"), name);
++	      continue;
++	    }
++
++	  sym = symtab + section->sh_info;
++
++	  if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
++	    {
++	      if (sym->st_shndx == 0
++		  || sym->st_shndx >= filedata->file_header.e_shnum)
++		{
++		  error (_("Bad sh_info in group section `%s'\n"), name);
++		  continue;
++		}
++
++	      group_name = SECTION_NAME_PRINT (filedata->section_headers
++					       + sym->st_shndx);
++	      strtab_sec = NULL;
++	      free (strtab);
++	      strtab = NULL;
++	      strtab_size = 0;
++	    }
++	  else
++	    {
++	      /* Get the string table.  */
++	      if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
++		{
++		  strtab_sec = NULL;
++		  free (strtab);
++		  strtab = NULL;
++		  strtab_size = 0;
++		}
++	      else if (strtab_sec
++		       != (sec = filedata->section_headers + symtab_sec->sh_link))
++		{
++		  strtab_sec = sec;
++		  free (strtab);
++
++		  strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
++					      1, strtab_sec->sh_size,
++					      _("string table"));
++		  strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
++		}
++	      group_name = sym->st_name < strtab_size
++		? strtab + sym->st_name : _("<corrupt>");
++	    }
++
++	  /* PR 17531: file: loop.  */
++	  if (section->sh_entsize > section->sh_size)
++	    {
++	      error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
++		     printable_section_name (filedata, section),
++		     (unsigned long) section->sh_entsize,
++		     (unsigned long) section->sh_size);
++	      continue;
++	    }
++
++	  start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
++                                              1, section->sh_size,
++                                              _("section data"));
++	  if (start == NULL)
++	    continue;
++
++	  indices = start;
++	  size = (section->sh_size / section->sh_entsize) - 1;
++	  entry = byte_get (indices, 4);
++	  indices += 4;
++
++	  if (do_section_groups)
++	    {
++	      printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
++		      get_group_flags (entry), i, name, group_name, size);
++
++	      printf (_("   [Index]    Name\n"));
++	    }
++
++	  group->group_index = i;
++
++	  for (j = 0; j < size; j++)
++	    {
++	      struct group_list * g;
++
++	      entry = byte_get (indices, 4);
++	      indices += 4;
++
++	      if (entry >= filedata->file_header.e_shnum)
++		{
++		  static unsigned num_group_errors = 0;
++
++		  if (num_group_errors ++ < 10)
++		    {
++		      error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
++			     entry, i, filedata->file_header.e_shnum - 1);
++		      if (num_group_errors == 10)
++			warn (_("Further error messages about overlarge group section indices suppressed\n"));
++		    }
++		  continue;
++		}
++
++	      if (filedata->section_headers_groups [entry] != NULL)
++		{
++		  if (entry)
++		    {
++		      static unsigned num_errs = 0;
++
++		      if (num_errs ++ < 10)
++			{
++			  error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
++				 entry, i,
++				 filedata->section_headers_groups [entry]->group_index);
++			  if (num_errs == 10)
++			    warn (_("Further error messages about already contained group sections suppressed\n"));
++			}
++		      continue;
++		    }
++		  else
++		    {
++		      /* Intel C/C++ compiler may put section 0 in a
++			 section group.  We just warn it the first time
++			 and ignore it afterwards.  */
++		      static bool warned = false;
++		      if (!warned)
++			{
++			  error (_("section 0 in group section [%5u]\n"),
++				 filedata->section_headers_groups [entry]->group_index);
++			  warned = true;
++			}
++		    }
++		}
++
++	      filedata->section_headers_groups [entry] = group;
++
++	      if (do_section_groups)
++		{
++		  sec = filedata->section_headers + entry;
++		  printf ("   [%5u]   %s\n", entry, printable_section_name (filedata, sec));
++		}
++
++	      g = (struct group_list *) xmalloc (sizeof (struct group_list));
++	      g->section_index = entry;
++	      g->next = group->root;
++	      group->root = g;
++	    }
++
++	  free (start);
++
++	  group++;
++	}
++    }
++
++  free (symtab);
++  free (strtab);
++  return true;
++}
++
++/* Data used to display dynamic fixups.  */
++
++struct ia64_vms_dynfixup
++{
++  bfd_vma needed_ident;		/* Library ident number.  */
++  bfd_vma needed;		/* Index in the dstrtab of the library name.  */
++  bfd_vma fixup_needed;		/* Index of the library.  */
++  bfd_vma fixup_rela_cnt;	/* Number of fixups.  */
++  bfd_vma fixup_rela_off;	/* Fixups offset in the dynamic segment.  */
++};
++
++/* Data used to display dynamic relocations.  */
++
++struct ia64_vms_dynimgrela
++{
++  bfd_vma img_rela_cnt;		/* Number of relocations.  */
++  bfd_vma img_rela_off;		/* Reloc offset in the dynamic segment.  */
++};
++
++/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
++   library).  */
++
++static bool
++dump_ia64_vms_dynamic_fixups (Filedata *                  filedata,
++			      struct ia64_vms_dynfixup *  fixup,
++                              const char *                strtab,
++			      unsigned int                strtab_sz)
++{
++  Elf64_External_VMS_IMAGE_FIXUP * imfs;
++  long i;
++  const char * lib_name;
++
++  imfs = get_data (NULL, filedata,
++		   filedata->dynamic_addr + fixup->fixup_rela_off,
++		   sizeof (*imfs), fixup->fixup_rela_cnt,
++		   _("dynamic section image fixups"));
++  if (!imfs)
++    return false;
++
++  if (fixup->needed < strtab_sz)
++    lib_name = strtab + fixup->needed;
++  else
++    {
++      warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
++            (unsigned long) fixup->needed);
++      lib_name = "???";
++    }
++
++  printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
++	  (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
++  printf
++    (_("Seg Offset           Type                             SymVec DataType\n"));
++
++  for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
++    {
++      unsigned int type;
++      const char *rtype;
++
++      printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
++      printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
++      type = BYTE_GET (imfs [i].type);
++      rtype = elf_ia64_reloc_type (type);
++      if (rtype == NULL)
++        printf (" 0x%08x                       ", type);
++      else
++        printf (" %-32s ", rtype);
++      printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
++      printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
++    }
++
++  free (imfs);
++  return true;
++}
++
++/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
++
++static bool
++dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
++{
++  Elf64_External_VMS_IMAGE_RELA *imrs;
++  long i;
++
++  imrs = get_data (NULL, filedata,
++		   filedata->dynamic_addr + imgrela->img_rela_off,
++		   sizeof (*imrs), imgrela->img_rela_cnt,
++		   _("dynamic section image relocations"));
++  if (!imrs)
++    return false;
++
++  printf (_("\nImage relocs\n"));
++  printf
++    (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
++
++  for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
++    {
++      unsigned int type;
++      const char *rtype;
++
++      printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
++      printf ("%08" BFD_VMA_FMT "x ",
++              (bfd_vma) BYTE_GET (imrs [i].rela_offset));
++      type = BYTE_GET (imrs [i].type);
++      rtype = elf_ia64_reloc_type (type);
++      if (rtype == NULL)
++        printf ("0x%08x                      ", type);
++      else
++        printf ("%-31s ", rtype);
++      print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
++      printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
++      printf ("%08" BFD_VMA_FMT "x\n",
++              (bfd_vma) BYTE_GET (imrs [i].sym_offset));
++    }
++
++  free (imrs);
++  return true;
++}
++
++/* Display IA-64 OpenVMS dynamic relocations and fixups.  */
++
++static bool
++process_ia64_vms_dynamic_relocs (Filedata * filedata)
++{
++  struct ia64_vms_dynfixup fixup;
++  struct ia64_vms_dynimgrela imgrela;
++  Elf_Internal_Dyn *entry;
++  bfd_vma strtab_off = 0;
++  bfd_vma strtab_sz = 0;
++  char *strtab = NULL;
++  bool res = true;
++
++  memset (&fixup, 0, sizeof (fixup));
++  memset (&imgrela, 0, sizeof (imgrela));
++
++  /* Note: the order of the entries is specified by the OpenVMS specs.  */
++  for (entry = filedata->dynamic_section;
++       entry < filedata->dynamic_section + filedata->dynamic_nent;
++       entry++)
++    {
++      switch (entry->d_tag)
++        {
++        case DT_IA_64_VMS_STRTAB_OFFSET:
++          strtab_off = entry->d_un.d_val;
++          break;
++        case DT_STRSZ:
++          strtab_sz = entry->d_un.d_val;
++          if (strtab == NULL)
++	    strtab = get_data (NULL, filedata,
++			       filedata->dynamic_addr + strtab_off,
++                               1, strtab_sz, _("dynamic string section"));
++	  if (strtab == NULL)
++	    strtab_sz = 0;
++          break;
++
++        case DT_IA_64_VMS_NEEDED_IDENT:
++          fixup.needed_ident = entry->d_un.d_val;
++          break;
++        case DT_NEEDED:
++          fixup.needed = entry->d_un.d_val;
++          break;
++        case DT_IA_64_VMS_FIXUP_NEEDED:
++          fixup.fixup_needed = entry->d_un.d_val;
++          break;
++        case DT_IA_64_VMS_FIXUP_RELA_CNT:
++          fixup.fixup_rela_cnt = entry->d_un.d_val;
++          break;
++        case DT_IA_64_VMS_FIXUP_RELA_OFF:
++          fixup.fixup_rela_off = entry->d_un.d_val;
++          if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
++	    res = false;
++          break;
++        case DT_IA_64_VMS_IMG_RELA_CNT:
++	  imgrela.img_rela_cnt = entry->d_un.d_val;
++          break;
++        case DT_IA_64_VMS_IMG_RELA_OFF:
++	  imgrela.img_rela_off = entry->d_un.d_val;
++          if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
++	    res = false;
++          break;
++
++        default:
++          break;
++	}
++    }
++
++  free (strtab);
++
++  return res;
++}
++
++static struct
++{
++  const char * name;
++  int reloc;
++  int size;
++  int rela;
++}
++  dynamic_relocations [] =
++{
++  { "REL", DT_REL, DT_RELSZ, false },
++  { "RELA", DT_RELA, DT_RELASZ, true },
++  { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
++};
++
++/* Process the reloc section.  */
++
++static bool
++process_relocs (Filedata * filedata)
++{
++  unsigned long rel_size;
++  unsigned long rel_offset;
++
++  if (!do_reloc)
++    return true;
++
++  if (do_using_dynamic)
++    {
++      int          is_rela;
++      const char * name;
++      bool  has_dynamic_reloc;
++      unsigned int i;
++
++      has_dynamic_reloc = false;
++
++      for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
++	{
++	  is_rela = dynamic_relocations [i].rela;
++	  name = dynamic_relocations [i].name;
++	  rel_size = filedata->dynamic_info[dynamic_relocations [i].size];
++	  rel_offset = filedata->dynamic_info[dynamic_relocations [i].reloc];
++
++	  if (rel_size)
++	    has_dynamic_reloc = true;
++
++	  if (is_rela == UNKNOWN)
++	    {
++	      if (dynamic_relocations [i].reloc == DT_JMPREL)
++		switch (filedata->dynamic_info[DT_PLTREL])
++		  {
++		  case DT_REL:
++		    is_rela = false;
++		    break;
++		  case DT_RELA:
++		    is_rela = true;
++		    break;
++		  }
++	    }
++
++	  if (rel_size)
++	    {
++	      if (filedata->is_separate)
++		printf
++		  (_("\nIn linked file '%s' section '%s' at offset 0x%lx contains %ld bytes:\n"),
++		   filedata->file_name, name, rel_offset, rel_size);
++	      else
++		printf
++		  (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
++		   name, rel_offset, rel_size);
++
++	      dump_relocations (filedata,
++				offset_from_vma (filedata, rel_offset, rel_size),
++				rel_size,
++				filedata->dynamic_symbols,
++				filedata->num_dynamic_syms,
++				filedata->dynamic_strings,
++				filedata->dynamic_strings_length,
++				is_rela, true /* is_dynamic */);
++	    }
++	}
++
++      if (is_ia64_vms (filedata))
++        if (process_ia64_vms_dynamic_relocs (filedata))
++	  has_dynamic_reloc = true;
++
++      if (! has_dynamic_reloc)
++	{
++	  if (filedata->is_separate)
++	    printf (_("\nThere are no dynamic relocations in linked file '%s'.\n"),
++		    filedata->file_name);
++	  else
++	    printf (_("\nThere are no dynamic relocations in this file.\n"));
++	}
++    }
++  else
++    {
++      Elf_Internal_Shdr * section;
++      unsigned long i;
++      bool found = false;
++
++      for (i = 0, section = filedata->section_headers;
++	   i < filedata->file_header.e_shnum;
++	   i++, section++)
++	{
++	  if (   section->sh_type != SHT_RELA
++	      && section->sh_type != SHT_REL)
++	    continue;
++
++	  rel_offset = section->sh_offset;
++	  rel_size   = section->sh_size;
++
++	  if (rel_size)
++	    {
++	      int is_rela;
++	      unsigned long num_rela;
++
++	      if (filedata->is_separate)
++		printf (_("\nIn linked file '%s' relocation section "),
++			filedata->file_name);
++	      else
++		printf (_("\nRelocation section "));
++
++	      if (filedata->string_table == NULL)
++		printf ("%d", section->sh_name);
++	      else
++		printf ("'%s'", printable_section_name (filedata, section));
++
++	      num_rela = rel_size / section->sh_entsize;
++	      printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
++				" at offset 0x%lx contains %lu entries:\n",
++				num_rela),
++		      rel_offset, num_rela);
++
++	      is_rela = section->sh_type == SHT_RELA;
++
++	      if (section->sh_link != 0
++		  && section->sh_link < filedata->file_header.e_shnum)
++		{
++		  Elf_Internal_Shdr * symsec;
++		  Elf_Internal_Sym *  symtab;
++		  unsigned long nsyms;
++		  unsigned long strtablen = 0;
++		  char * strtab = NULL;
++
++		  symsec = filedata->section_headers + section->sh_link;
++		  if (symsec->sh_type != SHT_SYMTAB
++		      && symsec->sh_type != SHT_DYNSYM)
++                    continue;
++
++		  if (!get_symtab (filedata, symsec,
++				   &symtab, &nsyms, &strtab, &strtablen))
++		    continue;
++
++		  dump_relocations (filedata, rel_offset, rel_size,
++				    symtab, nsyms, strtab, strtablen,
++				    is_rela,
++				    symsec->sh_type == SHT_DYNSYM);
++		  free (strtab);
++		  free (symtab);
++		}
++	      else
++		dump_relocations (filedata, rel_offset, rel_size,
++				  NULL, 0, NULL, 0, is_rela,
++				  false /* is_dynamic */);
++
++	      found = true;
++	    }
++	}
++
++      if (! found)
++	{
++	  /* Users sometimes forget the -D option, so try to be helpful.  */
++	  for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
++	    {
++	      if (filedata->dynamic_info[dynamic_relocations [i].size])
++		{
++		  if (filedata->is_separate)
++		    printf (_("\nThere are no static relocations in linked file '%s'."),
++			    filedata->file_name);
++		  else
++		    printf (_("\nThere are no static relocations in this file."));
++		  printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
++
++		  break;
++		}
++	    }
++	  if (i == ARRAY_SIZE (dynamic_relocations))
++	    {
++	      if (filedata->is_separate)
++		printf (_("\nThere are no relocations in linked file '%s'.\n"),
++			filedata->file_name);
++	      else
++		printf (_("\nThere are no relocations in this file.\n"));
++	    }
++	}
++    }
++
++  return true;
++}
++
++/* An absolute address consists of a section and an offset.  If the
++   section is NULL, the offset itself is the address, otherwise, the
++   address equals to LOAD_ADDRESS(section) + offset.  */
++
++struct absaddr
++{
++  unsigned short section;
++  bfd_vma offset;
++};
++
++/* Find the nearest symbol at or below ADDR.  Returns the symbol
++   name, if found, and the offset from the symbol to ADDR.  */
++
++static void
++find_symbol_for_address (Filedata *          filedata,
++			 Elf_Internal_Sym *  symtab,
++			 unsigned long       nsyms,
++			 const char *        strtab,
++			 unsigned long       strtab_size,
++			 struct absaddr      addr,
++			 const char **       symname,
++			 bfd_vma *           offset)
++{
++  bfd_vma dist = 0x100000;
++  Elf_Internal_Sym * sym;
++  Elf_Internal_Sym * beg;
++  Elf_Internal_Sym * end;
++  Elf_Internal_Sym * best = NULL;
++
++  REMOVE_ARCH_BITS (addr.offset);
++  beg = symtab;
++  end = symtab + nsyms;
++
++  while (beg < end)
++    {
++      bfd_vma value;
++
++      sym = beg + (end - beg) / 2;
++
++      value = sym->st_value;
++      REMOVE_ARCH_BITS (value);
++
++      if (sym->st_name != 0
++	  && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
++	  && addr.offset >= value
++	  && addr.offset - value < dist)
++	{
++	  best = sym;
++	  dist = addr.offset - value;
++	  if (!dist)
++	    break;
++	}
++
++      if (addr.offset < value)
++	end = sym;
++      else
++	beg = sym + 1;
++    }
++
++  if (best)
++    {
++      *symname = (best->st_name >= strtab_size
++		  ? _("<corrupt>") : strtab + best->st_name);
++      *offset = dist;
++      return;
++    }
++
++  *symname = NULL;
++  *offset = addr.offset;
++}
++
++static /* signed */ int
++symcmp (const void *p, const void *q)
++{
++  Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
++  Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
++
++  return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
++}
++
++/* Process the unwind section.  */
++
++#include "unwind-ia64.h"
++
++struct ia64_unw_table_entry
++{
++  struct absaddr start;
++  struct absaddr end;
++  struct absaddr info;
++};
++
++struct ia64_unw_aux_info
++{
++  struct ia64_unw_table_entry * table;		/* Unwind table.  */
++  unsigned long                 table_len;	/* Length of unwind table.  */
++  unsigned char *               info;		/* Unwind info.  */
++  unsigned long                 info_size;	/* Size of unwind info.  */
++  bfd_vma                       info_addr;	/* Starting address of unwind info.  */
++  bfd_vma                       seg_base;	/* Starting address of segment.  */
++  Elf_Internal_Sym *            symtab;		/* The symbol table.  */
++  unsigned long                 nsyms;		/* Number of symbols.  */
++  Elf_Internal_Sym *            funtab;		/* Sorted table of STT_FUNC symbols.  */
++  unsigned long                 nfuns;		/* Number of entries in funtab.  */
++  char *                        strtab;		/* The string table.  */
++  unsigned long                 strtab_size;	/* Size of string table.  */
++};
++
++static bool
++dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
++{
++  struct ia64_unw_table_entry * tp;
++  unsigned long j, nfuns;
++  int in_body;
++  bool res = true;
++
++  aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
++  for (nfuns = 0, j = 0; j < aux->nsyms; j++)
++    if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
++      aux->funtab[nfuns++] = aux->symtab[j];
++  aux->nfuns = nfuns;
++  qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
++
++  for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
++    {
++      bfd_vma stamp;
++      bfd_vma offset;
++      const unsigned char * dp;
++      const unsigned char * head;
++      const unsigned char * end;
++      const char * procname;
++
++      find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
++			       aux->strtab_size, tp->start, &procname, &offset);
++
++      fputs ("\n<", stdout);
++
++      if (procname)
++	{
++	  fputs (procname, stdout);
++
++	  if (offset)
++	    printf ("+%lx", (unsigned long) offset);
++	}
++
++      fputs (">: [", stdout);
++      print_vma (tp->start.offset, PREFIX_HEX);
++      fputc ('-', stdout);
++      print_vma (tp->end.offset, PREFIX_HEX);
++      printf ("], info at +0x%lx\n",
++	      (unsigned long) (tp->info.offset - aux->seg_base));
++
++      /* PR 17531: file: 86232b32.  */
++      if (aux->info == NULL)
++	continue;
++
++      offset = tp->info.offset;
++      if (tp->info.section)
++	{
++	  if (tp->info.section >= filedata->file_header.e_shnum)
++	    {
++	      warn (_("Invalid section %u in table entry %ld\n"),
++		    tp->info.section, (long) (tp - aux->table));
++	      res = false;
++	      continue;
++	    }
++	  offset += filedata->section_headers[tp->info.section].sh_addr;
++	}
++      offset -= aux->info_addr;
++      /* PR 17531: file: 0997b4d1.  */
++      if (offset >= aux->info_size
++	  || aux->info_size - offset < 8)
++	{
++	  warn (_("Invalid offset %lx in table entry %ld\n"),
++		(long) tp->info.offset, (long) (tp - aux->table));
++	  res = false;
++	  continue;
++	}
++
++      head = aux->info + offset;
++      stamp = byte_get ((unsigned char *) head, sizeof (stamp));
++
++      printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
++	      (unsigned) UNW_VER (stamp),
++	      (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
++	      UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
++	      UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
++	      (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
++
++      if (UNW_VER (stamp) != 1)
++	{
++	  printf (_("\tUnknown version.\n"));
++	  continue;
++	}
++
++      in_body = 0;
++      end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
++      /* PR 17531: file: 16ceda89.  */
++      if (end > aux->info + aux->info_size)
++	end = aux->info + aux->info_size;
++      for (dp = head + 8; dp < end;)
++	dp = unw_decode (dp, in_body, & in_body, end);
++    }
++
++  free (aux->funtab);
++
++  return res;
++}
++
++static bool
++slurp_ia64_unwind_table (Filedata *                  filedata,
++			 struct ia64_unw_aux_info *  aux,
++			 Elf_Internal_Shdr *         sec)
++{
++  unsigned long size, nrelas, i;
++  Elf_Internal_Phdr * seg;
++  struct ia64_unw_table_entry * tep;
++  Elf_Internal_Shdr * relsec;
++  Elf_Internal_Rela * rela;
++  Elf_Internal_Rela * rp;
++  unsigned char * table;
++  unsigned char * tp;
++  Elf_Internal_Sym * sym;
++  const char * relname;
++
++  aux->table_len = 0;
++
++  /* First, find the starting address of the segment that includes
++     this section: */
++
++  if (filedata->file_header.e_phnum)
++    {
++      if (! get_program_headers (filedata))
++	  return false;
++
++      for (seg = filedata->program_headers;
++	   seg < filedata->program_headers + filedata->file_header.e_phnum;
++	   ++seg)
++	{
++	  if (seg->p_type != PT_LOAD)
++	    continue;
++
++	  if (sec->sh_addr >= seg->p_vaddr
++	      && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
++	    {
++	      aux->seg_base = seg->p_vaddr;
++	      break;
++	    }
++	}
++    }
++
++  /* Second, build the unwind table from the contents of the unwind section:  */
++  size = sec->sh_size;
++  table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
++                                      _("unwind table"));
++  if (!table)
++    return false;
++
++  aux->table_len = size / (3 * eh_addr_size);
++  aux->table = (struct ia64_unw_table_entry *)
++    xcmalloc (aux->table_len, sizeof (aux->table[0]));
++  tep = aux->table;
++
++  for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
++    {
++      tep->start.section = SHN_UNDEF;
++      tep->end.section   = SHN_UNDEF;
++      tep->info.section  = SHN_UNDEF;
++      tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
++      tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
++      tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
++      tep->start.offset += aux->seg_base;
++      tep->end.offset   += aux->seg_base;
++      tep->info.offset  += aux->seg_base;
++    }
++  free (table);
++
++  /* Third, apply any relocations to the unwind table:  */
++  for (relsec = filedata->section_headers;
++       relsec < filedata->section_headers + filedata->file_header.e_shnum;
++       ++relsec)
++    {
++      if (relsec->sh_type != SHT_RELA
++	  || relsec->sh_info >= filedata->file_header.e_shnum
++	  || filedata->section_headers + relsec->sh_info != sec)
++	continue;
++
++      if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
++			      & rela, & nrelas))
++	{
++	  free (aux->table);
++	  aux->table = NULL;
++	  aux->table_len = 0;
++	  return false;
++	}
++
++      for (rp = rela; rp < rela + nrelas; ++rp)
++	{
++	  unsigned int sym_ndx;
++	  unsigned int r_type = get_reloc_type (filedata, rp->r_info);
++	  relname = elf_ia64_reloc_type (r_type);
++
++	  /* PR 17531: file: 9fa67536.  */
++	  if (relname == NULL)
++	    {
++	      warn (_("Skipping unknown relocation type: %u\n"), r_type);
++	      continue;
++	    }
++
++	  if (! startswith (relname, "R_IA64_SEGREL"))
++	    {
++	      warn (_("Skipping unexpected relocation type: %s\n"), relname);
++	      continue;
++	    }
++
++	  i = rp->r_offset / (3 * eh_addr_size);
++
++	  /* PR 17531: file: 5bc8d9bf.  */
++	  if (i >= aux->table_len)
++	    {
++	      warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
++	      continue;
++	    }
++
++	  sym_ndx = get_reloc_symindex (rp->r_info);
++	  if (sym_ndx >= aux->nsyms)
++	    {
++	      warn (_("Skipping reloc with invalid symbol index: %u\n"),
++		    sym_ndx);
++	      continue;
++	    }
++	  sym = aux->symtab + sym_ndx;
++
++	  switch (rp->r_offset / eh_addr_size % 3)
++	    {
++	    case 0:
++	      aux->table[i].start.section = sym->st_shndx;
++	      aux->table[i].start.offset  = rp->r_addend + sym->st_value;
++	      break;
++	    case 1:
++	      aux->table[i].end.section   = sym->st_shndx;
++	      aux->table[i].end.offset    = rp->r_addend + sym->st_value;
++	      break;
++	    case 2:
++	      aux->table[i].info.section  = sym->st_shndx;
++	      aux->table[i].info.offset   = rp->r_addend + sym->st_value;
++	      break;
++	    default:
++	      break;
++	    }
++	}
++
++      free (rela);
++    }
++
++  return true;
++}
++
++static bool
++ia64_process_unwind (Filedata * filedata)
++{
++  Elf_Internal_Shdr * sec;
++  Elf_Internal_Shdr * unwsec = NULL;
++  unsigned long i, unwcount = 0, unwstart = 0;
++  struct ia64_unw_aux_info aux;
++  bool res = true;
++
++  memset (& aux, 0, sizeof (aux));
++
++  for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
++    {
++      if (sec->sh_type == SHT_SYMTAB)
++	{
++	  if (aux.symtab)
++	    {
++	      error (_("Multiple symbol tables encountered\n"));
++	      free (aux.symtab);
++	      aux.symtab = NULL;
++	      free (aux.strtab);
++	      aux.strtab = NULL;
++	    }
++	  if (!get_symtab (filedata, sec, &aux.symtab, &aux.nsyms,
++			   &aux.strtab, &aux.strtab_size))
++	    return false;
++	}
++      else if (sec->sh_type == SHT_IA_64_UNWIND)
++	unwcount++;
++    }
++
++  if (!unwcount)
++    printf (_("\nThere are no unwind sections in this file.\n"));
++
++  while (unwcount-- > 0)
++    {
++      char * suffix;
++      size_t len, len2;
++
++      for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
++	   i < filedata->file_header.e_shnum; ++i, ++sec)
++	if (sec->sh_type == SHT_IA_64_UNWIND)
++	  {
++	    unwsec = sec;
++	    break;
++	  }
++      /* We have already counted the number of SHT_IA64_UNWIND
++	 sections so the loop above should never fail.  */
++      assert (unwsec != NULL);
++
++      unwstart = i + 1;
++      len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
++
++      if ((unwsec->sh_flags & SHF_GROUP) != 0)
++	{
++	  /* We need to find which section group it is in.  */
++	  struct group_list * g;
++
++	  if (filedata->section_headers_groups == NULL
++	      || filedata->section_headers_groups[i] == NULL)
++	    i = filedata->file_header.e_shnum;
++	  else
++	    {
++	      g = filedata->section_headers_groups[i]->root;
++
++	      for (; g != NULL; g = g->next)
++		{
++		  sec = filedata->section_headers + g->section_index;
++
++		  if (SECTION_NAME_VALID (sec)
++		      && streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
++		    break;
++		}
++
++	      if (g == NULL)
++		i = filedata->file_header.e_shnum;
++	    }
++	}
++      else if (SECTION_NAME_VALID (unwsec)
++	       && startswith (SECTION_NAME (unwsec),
++			      ELF_STRING_ia64_unwind_once))
++	{
++	  /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
++	  len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
++	  suffix = SECTION_NAME (unwsec) + len;
++	  for (i = 0, sec = filedata->section_headers;
++	       i < filedata->file_header.e_shnum;
++	       ++i, ++sec)
++	    if (SECTION_NAME_VALID (sec)
++		&& startswith (SECTION_NAME (sec),
++			       ELF_STRING_ia64_unwind_info_once)
++		&& streq (SECTION_NAME (sec) + len2, suffix))
++	      break;
++	}
++      else
++	{
++	  /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
++	     .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
++	  len = sizeof (ELF_STRING_ia64_unwind) - 1;
++	  len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
++	  suffix = "";
++	  if (SECTION_NAME_VALID (unwsec)
++	      && startswith (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind))
++	    suffix = SECTION_NAME (unwsec) + len;
++	  for (i = 0, sec = filedata->section_headers;
++	       i < filedata->file_header.e_shnum;
++	       ++i, ++sec)
++	    if (SECTION_NAME_VALID (sec)
++		&& startswith (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info)
++		&& streq (SECTION_NAME (sec) + len2, suffix))
++	      break;
++	}
++
++      if (i == filedata->file_header.e_shnum)
++	{
++	  printf (_("\nCould not find unwind info section for "));
++
++	  if (filedata->string_table == NULL)
++	    printf ("%d", unwsec->sh_name);
++	  else
++	    printf ("'%s'", printable_section_name (filedata, unwsec));
++	}
++      else
++	{
++	  aux.info_addr = sec->sh_addr;
++	  aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
++						 sec->sh_size,
++						 _("unwind info"));
++	  aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
++
++	  printf (_("\nUnwind section "));
++
++	  if (filedata->string_table == NULL)
++	    printf ("%d", unwsec->sh_name);
++	  else
++	    printf ("'%s'", printable_section_name (filedata, unwsec));
++
++	  printf (_(" at offset 0x%lx contains %lu entries:\n"),
++		  (unsigned long) unwsec->sh_offset,
++		  (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
++
++	  if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
++	      && aux.table_len > 0)
++	    dump_ia64_unwind (filedata, & aux);
++
++	  free ((char *) aux.table);
++	  free ((char *) aux.info);
++	  aux.table = NULL;
++	  aux.info = NULL;
++	}
++    }
++
++  free (aux.symtab);
++  free ((char *) aux.strtab);
++
++  return res;
++}
++
++struct hppa_unw_table_entry
++{
++  struct absaddr start;
++  struct absaddr end;
++  unsigned int Cannot_unwind:1;			/* 0 */
++  unsigned int Millicode:1;			/* 1 */
++  unsigned int Millicode_save_sr0:1;		/* 2 */
++  unsigned int Region_description:2;		/* 3..4 */
++  unsigned int reserved1:1;			/* 5 */
++  unsigned int Entry_SR:1;			/* 6 */
++  unsigned int Entry_FR:4;     /* Number saved     7..10 */
++  unsigned int Entry_GR:5;     /* Number saved     11..15 */
++  unsigned int Args_stored:1;			/* 16 */
++  unsigned int Variable_Frame:1;		/* 17 */
++  unsigned int Separate_Package_Body:1;		/* 18 */
++  unsigned int Frame_Extension_Millicode:1;	/* 19 */
++  unsigned int Stack_Overflow_Check:1;		/* 20 */
++  unsigned int Two_Instruction_SP_Increment:1;	/* 21 */
++  unsigned int Ada_Region:1;			/* 22 */
++  unsigned int cxx_info:1;			/* 23 */
++  unsigned int cxx_try_catch:1;			/* 24 */
++  unsigned int sched_entry_seq:1;		/* 25 */
++  unsigned int reserved2:1;			/* 26 */
++  unsigned int Save_SP:1;			/* 27 */
++  unsigned int Save_RP:1;			/* 28 */
++  unsigned int Save_MRP_in_frame:1;		/* 29 */
++  unsigned int extn_ptr_defined:1;		/* 30 */
++  unsigned int Cleanup_defined:1;		/* 31 */
++
++  unsigned int MPE_XL_interrupt_marker:1;	/* 0 */
++  unsigned int HP_UX_interrupt_marker:1;	/* 1 */
++  unsigned int Large_frame:1;			/* 2 */
++  unsigned int Pseudo_SP_Set:1;			/* 3 */
++  unsigned int reserved4:1;			/* 4 */
++  unsigned int Total_frame_size:27;		/* 5..31 */
++};
++
++struct hppa_unw_aux_info
++{
++  struct hppa_unw_table_entry *  table;		/* Unwind table.  */
++  unsigned long                  table_len;	/* Length of unwind table.  */
++  bfd_vma                        seg_base;	/* Starting address of segment.  */
++  Elf_Internal_Sym *             symtab;	/* The symbol table.  */
++  unsigned long                  nsyms;		/* Number of symbols.  */
++  Elf_Internal_Sym *             funtab;	/* Sorted table of STT_FUNC symbols.  */
++  unsigned long                  nfuns;		/* Number of entries in funtab.  */
++  char *                         strtab;	/* The string table.  */
++  unsigned long                  strtab_size;	/* Size of string table.  */
++};
++
++static bool
++dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
++{
++  struct hppa_unw_table_entry * tp;
++  unsigned long j, nfuns;
++  bool res = true;
++
++  aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
++  for (nfuns = 0, j = 0; j < aux->nsyms; j++)
++    if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
++      aux->funtab[nfuns++] = aux->symtab[j];
++  aux->nfuns = nfuns;
++  qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
++
++  for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
++    {
++      bfd_vma offset;
++      const char * procname;
++
++      find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
++			       aux->strtab_size, tp->start, &procname,
++			       &offset);
++
++      fputs ("\n<", stdout);
++
++      if (procname)
++	{
++	  fputs (procname, stdout);
++
++	  if (offset)
++	    printf ("+%lx", (unsigned long) offset);
++	}
++
++      fputs (">: [", stdout);
++      print_vma (tp->start.offset, PREFIX_HEX);
++      fputc ('-', stdout);
++      print_vma (tp->end.offset, PREFIX_HEX);
++      printf ("]\n\t");
++
++#define PF(_m) if (tp->_m) printf (#_m " ");
++#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
++      PF(Cannot_unwind);
++      PF(Millicode);
++      PF(Millicode_save_sr0);
++      /* PV(Region_description);  */
++      PF(Entry_SR);
++      PV(Entry_FR);
++      PV(Entry_GR);
++      PF(Args_stored);
++      PF(Variable_Frame);
++      PF(Separate_Package_Body);
++      PF(Frame_Extension_Millicode);
++      PF(Stack_Overflow_Check);
++      PF(Two_Instruction_SP_Increment);
++      PF(Ada_Region);
++      PF(cxx_info);
++      PF(cxx_try_catch);
++      PF(sched_entry_seq);
++      PF(Save_SP);
++      PF(Save_RP);
++      PF(Save_MRP_in_frame);
++      PF(extn_ptr_defined);
++      PF(Cleanup_defined);
++      PF(MPE_XL_interrupt_marker);
++      PF(HP_UX_interrupt_marker);
++      PF(Large_frame);
++      PF(Pseudo_SP_Set);
++      PV(Total_frame_size);
++#undef PF
++#undef PV
++    }
++
++  printf ("\n");
++
++  free (aux->funtab);
++
++  return res;
++}
++
++static bool
++slurp_hppa_unwind_table (Filedata *                  filedata,
++			 struct hppa_unw_aux_info *  aux,
++			 Elf_Internal_Shdr *         sec)
++{
++  unsigned long size, unw_ent_size, nentries, nrelas, i;
++  Elf_Internal_Phdr * seg;
++  struct hppa_unw_table_entry * tep;
++  Elf_Internal_Shdr * relsec;
++  Elf_Internal_Rela * rela;
++  Elf_Internal_Rela * rp;
++  unsigned char * table;
++  unsigned char * tp;
++  Elf_Internal_Sym * sym;
++  const char * relname;
++
++  /* First, find the starting address of the segment that includes
++     this section.  */
++  if (filedata->file_header.e_phnum)
++    {
++      if (! get_program_headers (filedata))
++	return false;
++
++      for (seg = filedata->program_headers;
++	   seg < filedata->program_headers + filedata->file_header.e_phnum;
++	   ++seg)
++	{
++	  if (seg->p_type != PT_LOAD)
++	    continue;
++
++	  if (sec->sh_addr >= seg->p_vaddr
++	      && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
++	    {
++	      aux->seg_base = seg->p_vaddr;
++	      break;
++	    }
++	}
++    }
++
++  /* Second, build the unwind table from the contents of the unwind
++     section.  */
++  size = sec->sh_size;
++  table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
++                                      _("unwind table"));
++  if (!table)
++    return false;
++
++  unw_ent_size = 16;
++  nentries = size / unw_ent_size;
++  size = unw_ent_size * nentries;
++
++  aux->table_len = nentries;
++  tep = aux->table = (struct hppa_unw_table_entry *)
++      xcmalloc (nentries, sizeof (aux->table[0]));
++
++  for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
++    {
++      unsigned int tmp1, tmp2;
++
++      tep->start.section = SHN_UNDEF;
++      tep->end.section   = SHN_UNDEF;
++
++      tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
++      tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
++      tmp1 = byte_get ((unsigned char *) tp + 8, 4);
++      tmp2 = byte_get ((unsigned char *) tp + 12, 4);
++
++      tep->start.offset += aux->seg_base;
++      tep->end.offset   += aux->seg_base;
++
++      tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
++      tep->Millicode = (tmp1 >> 30) & 0x1;
++      tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
++      tep->Region_description = (tmp1 >> 27) & 0x3;
++      tep->reserved1 = (tmp1 >> 26) & 0x1;
++      tep->Entry_SR = (tmp1 >> 25) & 0x1;
++      tep->Entry_FR = (tmp1 >> 21) & 0xf;
++      tep->Entry_GR = (tmp1 >> 16) & 0x1f;
++      tep->Args_stored = (tmp1 >> 15) & 0x1;
++      tep->Variable_Frame = (tmp1 >> 14) & 0x1;
++      tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
++      tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
++      tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
++      tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
++      tep->Ada_Region = (tmp1 >> 9) & 0x1;
++      tep->cxx_info = (tmp1 >> 8) & 0x1;
++      tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
++      tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
++      tep->reserved2 = (tmp1 >> 5) & 0x1;
++      tep->Save_SP = (tmp1 >> 4) & 0x1;
++      tep->Save_RP = (tmp1 >> 3) & 0x1;
++      tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
++      tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
++      tep->Cleanup_defined = tmp1 & 0x1;
++
++      tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
++      tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
++      tep->Large_frame = (tmp2 >> 29) & 0x1;
++      tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
++      tep->reserved4 = (tmp2 >> 27) & 0x1;
++      tep->Total_frame_size = tmp2 & 0x7ffffff;
++    }
++  free (table);
++
++  /* Third, apply any relocations to the unwind table.  */
++  for (relsec = filedata->section_headers;
++       relsec < filedata->section_headers + filedata->file_header.e_shnum;
++       ++relsec)
++    {
++      if (relsec->sh_type != SHT_RELA
++	  || relsec->sh_info >= filedata->file_header.e_shnum
++	  || filedata->section_headers + relsec->sh_info != sec)
++	continue;
++
++      if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
++			      & rela, & nrelas))
++	return false;
++
++      for (rp = rela; rp < rela + nrelas; ++rp)
++	{
++	  unsigned int sym_ndx;
++	  unsigned int r_type = get_reloc_type (filedata, rp->r_info);
++	  relname = elf_hppa_reloc_type (r_type);
++
++	  if (relname == NULL)
++	    {
++	      warn (_("Skipping unknown relocation type: %u\n"), r_type);
++	      continue;
++	    }
++
++	  /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
++	  if (! startswith (relname, "R_PARISC_SEGREL"))
++	    {
++	      warn (_("Skipping unexpected relocation type: %s\n"), relname);
++	      continue;
++	    }
++
++	  i = rp->r_offset / unw_ent_size;
++	  if (i >= aux->table_len)
++	    {
++	      warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
++	      continue;
++	    }
++
++	  sym_ndx = get_reloc_symindex (rp->r_info);
++	  if (sym_ndx >= aux->nsyms)
++	    {
++	      warn (_("Skipping reloc with invalid symbol index: %u\n"),
++		    sym_ndx);
++	      continue;
++	    }
++	  sym = aux->symtab + sym_ndx;
++
++	  switch ((rp->r_offset % unw_ent_size) / 4)
++	    {
++	    case 0:
++	      aux->table[i].start.section = sym->st_shndx;
++	      aux->table[i].start.offset  = sym->st_value + rp->r_addend;
++	      break;
++	    case 1:
++	      aux->table[i].end.section   = sym->st_shndx;
++	      aux->table[i].end.offset    = sym->st_value + rp->r_addend;
++	      break;
++	    default:
++	      break;
++	    }
++	}
++
++      free (rela);
++    }
++
++  return true;
++}
++
++static bool
++hppa_process_unwind (Filedata * filedata)
++{
++  struct hppa_unw_aux_info aux;
++  Elf_Internal_Shdr * unwsec = NULL;
++  Elf_Internal_Shdr * sec;
++  unsigned long i;
++  bool res = true;
++
++  if (filedata->string_table == NULL)
++    return false;
++
++  memset (& aux, 0, sizeof (aux));
++
++  for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
++    {
++      if (sec->sh_type == SHT_SYMTAB)
++	{
++	  if (aux.symtab)
++	    {
++	      error (_("Multiple symbol tables encountered\n"));
++	      free (aux.symtab);
++	      aux.symtab = NULL;
++	      free (aux.strtab);
++	      aux.strtab = NULL;
++	    }
++	  if (!get_symtab (filedata, sec, &aux.symtab, &aux.nsyms,
++			   &aux.strtab, &aux.strtab_size))
++	    return false;
++	}
++      else if (SECTION_NAME_VALID (sec)
++	       && streq (SECTION_NAME (sec), ".PARISC.unwind"))
++	unwsec = sec;
++    }
++
++  if (!unwsec)
++    printf (_("\nThere are no unwind sections in this file.\n"));
++
++  for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
++    {
++      if (SECTION_NAME_VALID (sec)
++	  && streq (SECTION_NAME (sec), ".PARISC.unwind"))
++	{
++	  unsigned long num_unwind = sec->sh_size / 16;
++
++	  printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
++			    "contains %lu entry:\n",
++			    "\nUnwind section '%s' at offset 0x%lx "
++			    "contains %lu entries:\n",
++			    num_unwind),
++		  printable_section_name (filedata, sec),
++		  (unsigned long) sec->sh_offset,
++		  num_unwind);
++
++          if (! slurp_hppa_unwind_table (filedata, &aux, sec))
++	    res = false;
++
++	  if (res && aux.table_len > 0)
++	    {
++	      if (! dump_hppa_unwind (filedata, &aux))
++		res = false;
++	    }
++
++	  free ((char *) aux.table);
++	  aux.table = NULL;
++	}
++    }
++
++  free (aux.symtab);
++  free ((char *) aux.strtab);
++
++  return res;
++}
++
++struct arm_section
++{
++  unsigned char *      data;		/* The unwind data.  */
++  Elf_Internal_Shdr *  sec;		/* The cached unwind section header.  */
++  Elf_Internal_Rela *  rela;		/* The cached relocations for this section.  */
++  unsigned long        nrelas;		/* The number of relocations.  */
++  unsigned int         rel_type;	/* REL or RELA ?  */
++  Elf_Internal_Rela *  next_rela;	/* Cyclic pointer to the next reloc to process.  */
++};
++
++struct arm_unw_aux_info
++{
++  Filedata *          filedata;		/* The file containing the unwind sections.  */
++  Elf_Internal_Sym *  symtab;		/* The file's symbol table.  */
++  unsigned long       nsyms;		/* Number of symbols.  */
++  Elf_Internal_Sym *  funtab;		/* Sorted table of STT_FUNC symbols.  */
++  unsigned long       nfuns;		/* Number of these symbols.  */
++  char *              strtab;		/* The file's string table.  */
++  unsigned long       strtab_size;	/* Size of string table.  */
++};
++
++static const char *
++arm_print_vma_and_name (Filedata *                 filedata,
++			struct arm_unw_aux_info *  aux,
++			bfd_vma                    fn,
++			struct absaddr             addr)
++{
++  const char *procname;
++  bfd_vma sym_offset;
++
++  if (addr.section == SHN_UNDEF)
++    addr.offset = fn;
++
++  find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
++			   aux->strtab_size, addr, &procname,
++			   &sym_offset);
++
++  print_vma (fn, PREFIX_HEX);
++
++  if (procname)
++    {
++      fputs (" <", stdout);
++      fputs (procname, stdout);
++
++      if (sym_offset)
++	printf ("+0x%lx", (unsigned long) sym_offset);
++      fputc ('>', stdout);
++    }
++
++  return procname;
++}
++
++static void
++arm_free_section (struct arm_section *arm_sec)
++{
++  free (arm_sec->data);
++  free (arm_sec->rela);
++}
++
++/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
++      cached section and install SEC instead.
++   2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
++      and return its valued in * WORDP, relocating if necessary.
++   3) Update the NEXT_RELA field in ARM_SEC and store the section index and
++      relocation's offset in ADDR.
++   4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
++      into the string table of the symbol associated with the reloc.  If no
++      reloc was applied store -1 there.
++   5) Return TRUE upon success, FALSE otherwise.  */
++
++static bool
++get_unwind_section_word (Filedata *                 filedata,
++			 struct arm_unw_aux_info *  aux,
++			 struct arm_section *       arm_sec,
++			 Elf_Internal_Shdr *        sec,
++			 bfd_vma 		    word_offset,
++			 unsigned int *             wordp,
++			 struct absaddr *           addr,
++			 bfd_vma *		    sym_name)
++{
++  Elf_Internal_Rela *rp;
++  Elf_Internal_Sym *sym;
++  const char * relname;
++  unsigned int word;
++  bool wrapped;
++
++  if (sec == NULL || arm_sec == NULL)
++    return false;
++
++  addr->section = SHN_UNDEF;
++  addr->offset = 0;
++
++  if (sym_name != NULL)
++    *sym_name = (bfd_vma) -1;
++
++  /* If necessary, update the section cache.  */
++  if (sec != arm_sec->sec)
++    {
++      Elf_Internal_Shdr *relsec;
++
++      arm_free_section (arm_sec);
++
++      arm_sec->sec = sec;
++      arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
++				sec->sh_size, _("unwind data"));
++      arm_sec->rela = NULL;
++      arm_sec->nrelas = 0;
++
++      for (relsec = filedata->section_headers;
++	   relsec < filedata->section_headers + filedata->file_header.e_shnum;
++	   ++relsec)
++	{
++	  if (relsec->sh_info >= filedata->file_header.e_shnum
++	      || filedata->section_headers + relsec->sh_info != sec
++	      /* PR 15745: Check the section type as well.  */
++	      || (relsec->sh_type != SHT_REL
++		  && relsec->sh_type != SHT_RELA))
++	    continue;
++
++	  arm_sec->rel_type = relsec->sh_type;
++	  if (relsec->sh_type == SHT_REL)
++	    {
++	      if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
++				     relsec->sh_size,
++				     & arm_sec->rela, & arm_sec->nrelas))
++		return false;
++	    }
++	  else /* relsec->sh_type == SHT_RELA */
++	    {
++	      if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
++				      relsec->sh_size,
++				      & arm_sec->rela, & arm_sec->nrelas))
++		return false;
++	    }
++	  break;
++	}
++
++      arm_sec->next_rela = arm_sec->rela;
++    }
++
++  /* If there is no unwind data we can do nothing.  */
++  if (arm_sec->data == NULL)
++    return false;
++
++  /* If the offset is invalid then fail.  */
++  if (/* PR 21343 *//* PR 18879 */
++      sec->sh_size < 4
++      || word_offset > (sec->sh_size - 4)
++      || ((bfd_signed_vma) word_offset) < 0)
++    return false;
++
++  /* Get the word at the required offset.  */
++  word = byte_get (arm_sec->data + word_offset, 4);
++
++  /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
++  if (arm_sec->rela == NULL)
++    {
++      * wordp = word;
++      return true;
++    }
++
++  /* Look through the relocs to find the one that applies to the provided offset.  */
++  wrapped = false;
++  for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
++    {
++      bfd_vma prelval, offset;
++
++      if (rp->r_offset > word_offset && !wrapped)
++	{
++	  rp = arm_sec->rela;
++	  wrapped = true;
++	}
++      if (rp->r_offset > word_offset)
++	break;
++
++      if (rp->r_offset & 3)
++	{
++	  warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
++		(unsigned long) rp->r_offset);
++	  continue;
++	}
++
++      if (rp->r_offset < word_offset)
++	continue;
++
++      /* PR 17531: file: 027-161405-0.004  */
++      if (aux->symtab == NULL)
++	continue;
++
++      if (arm_sec->rel_type == SHT_REL)
++	{
++	  offset = word & 0x7fffffff;
++	  if (offset & 0x40000000)
++	    offset |= ~ (bfd_vma) 0x7fffffff;
++	}
++      else if (arm_sec->rel_type == SHT_RELA)
++	offset = rp->r_addend;
++      else
++	{
++	  error (_("Unknown section relocation type %d encountered\n"),
++		 arm_sec->rel_type);
++	  break;
++	}
++
++      /* PR 17531 file: 027-1241568-0.004.  */
++      if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
++	{
++	  error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
++		 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
++	  break;
++	}
++
++      sym = aux->symtab + ELF32_R_SYM (rp->r_info);
++      offset += sym->st_value;
++      prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
++
++      /* Check that we are processing the expected reloc type.  */
++      if (filedata->file_header.e_machine == EM_ARM)
++	{
++	  relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
++	  if (relname == NULL)
++	    {
++	      warn (_("Skipping unknown ARM relocation type: %d\n"),
++		    (int) ELF32_R_TYPE (rp->r_info));
++	      continue;
++	    }
++
++	  if (streq (relname, "R_ARM_NONE"))
++	      continue;
++
++	  if (! streq (relname, "R_ARM_PREL31"))
++	    {
++	      warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
++	      continue;
++	    }
++	}
++      else if (filedata->file_header.e_machine == EM_TI_C6000)
++	{
++	  relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
++	  if (relname == NULL)
++	    {
++	      warn (_("Skipping unknown C6000 relocation type: %d\n"),
++		    (int) ELF32_R_TYPE (rp->r_info));
++	      continue;
++	    }
++
++	  if (streq (relname, "R_C6000_NONE"))
++	    continue;
++
++	  if (! streq (relname, "R_C6000_PREL31"))
++	    {
++	      warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
++	      continue;
++	    }
++
++	  prelval >>= 1;
++	}
++      else
++	{
++	  /* This function currently only supports ARM and TI unwinders.  */
++	  warn (_("Only TI and ARM unwinders are currently supported\n"));
++	  break;
++	}
++
++      word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
++      addr->section = sym->st_shndx;
++      addr->offset = offset;
++
++      if (sym_name)
++	* sym_name = sym->st_name;
++      break;
++    }
++
++  *wordp = word;
++  arm_sec->next_rela = rp;
++
++  return true;
++}
++
++static const char *tic6x_unwind_regnames[16] =
++{
++  "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
++  "A14", "A13", "A12", "A11", "A10",
++  "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
++};
++
++static void
++decode_tic6x_unwind_regmask (unsigned int mask)
++{
++  int i;
++
++  for (i = 12; mask; mask >>= 1, i--)
++    {
++      if (mask & 1)
++	{
++	  fputs (tic6x_unwind_regnames[i], stdout);
++	  if (mask > 1)
++	    fputs (", ", stdout);
++	}
++    }
++}
++
++#define ADVANCE							\
++  if (remaining == 0 && more_words)				\
++    {								\
++      data_offset += 4;						\
++      if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec,	\
++				     data_offset, & word, & addr, NULL))	\
++	return false;						\
++      remaining = 4;						\
++      more_words--;						\
++    }								\
++
++#define GET_OP(OP)			\
++  ADVANCE;				\
++  if (remaining)			\
++    {					\
++      remaining--;			\
++      (OP) = word >> 24;		\
++      word <<= 8;			\
++    }					\
++  else					\
++    {					\
++      printf (_("[Truncated opcode]\n"));	\
++      return false;			\
++    }					\
++  printf ("0x%02x ", OP)
++
++static bool
++decode_arm_unwind_bytecode (Filedata *                 filedata,
++			    struct arm_unw_aux_info *  aux,
++			    unsigned int               word,
++			    unsigned int               remaining,
++			    unsigned int               more_words,
++			    bfd_vma                    data_offset,
++			    Elf_Internal_Shdr *        data_sec,
++			    struct arm_section *       data_arm_sec)
++{
++  struct absaddr addr;
++  bool res = true;
++
++  /* Decode the unwinding instructions.  */
++  while (1)
++    {
++      unsigned int op, op2;
++
++      ADVANCE;
++      if (remaining == 0)
++	break;
++      remaining--;
++      op = word >> 24;
++      word <<= 8;
++
++      printf ("  0x%02x ", op);
++
++      if ((op & 0xc0) == 0x00)
++	{
++	  int offset = ((op & 0x3f) << 2) + 4;
++
++	  printf ("     vsp = vsp + %d", offset);
++	}
++      else if ((op & 0xc0) == 0x40)
++	{
++	  int offset = ((op & 0x3f) << 2) + 4;
++
++	  printf ("     vsp = vsp - %d", offset);
++	}
++      else if ((op & 0xf0) == 0x80)
++	{
++	  GET_OP (op2);
++	  if (op == 0x80 && op2 == 0)
++	    printf (_("Refuse to unwind"));
++	  else
++	    {
++	      unsigned int mask = ((op & 0x0f) << 8) | op2;
++	      bool first = true;
++	      int i;
++
++	      printf ("pop {");
++	      for (i = 0; i < 12; i++)
++		if (mask & (1 << i))
++		  {
++		    if (first)
++		      first = false;
++		    else
++		      printf (", ");
++		    printf ("r%d", 4 + i);
++		  }
++	      printf ("}");
++	    }
++	}
++      else if ((op & 0xf0) == 0x90)
++	{
++	  if (op == 0x9d || op == 0x9f)
++	    printf (_("     [Reserved]"));
++	  else
++	    printf ("     vsp = r%d", op & 0x0f);
++	}
++      else if ((op & 0xf0) == 0xa0)
++	{
++	  int end = 4 + (op & 0x07);
++	  bool first = true;
++	  int i;
++
++	  printf ("     pop {");
++	  for (i = 4; i <= end; i++)
++	    {
++	      if (first)
++		first = false;
++	      else
++		printf (", ");
++	      printf ("r%d", i);
++	    }
++	  if (op & 0x08)
++	    {
++	      if (!first)
++		printf (", ");
++	      printf ("r14");
++	    }
++	  printf ("}");
++	}
++      else if (op == 0xb0)
++	printf (_("     finish"));
++      else if (op == 0xb1)
++	{
++	  GET_OP (op2);
++	  if (op2 == 0 || (op2 & 0xf0) != 0)
++	    printf (_("[Spare]"));
++	  else
++	    {
++	      unsigned int mask = op2 & 0x0f;
++	      bool first = true;
++	      int i;
++
++	      printf ("pop {");
++	      for (i = 0; i < 12; i++)
++		if (mask & (1 << i))
++		  {
++		    if (first)
++		      first = false;
++		    else
++		      printf (", ");
++		    printf ("r%d", i);
++		  }
++	      printf ("}");
++	    }
++	}
++      else if (op == 0xb2)
++	{
++	  unsigned char buf[9];
++	  unsigned int i, len;
++	  unsigned long offset;
++
++	  for (i = 0; i < sizeof (buf); i++)
++	    {
++	      GET_OP (buf[i]);
++	      if ((buf[i] & 0x80) == 0)
++		break;
++	    }
++	  if (i == sizeof (buf))
++	    {
++	      error (_("corrupt change to vsp\n"));
++	      res = false;
++	    }
++	  else
++	    {
++	      offset = read_leb128 (buf, buf + i + 1, false, &len, NULL);
++	      assert (len == i + 1);
++	      offset = offset * 4 + 0x204;
++	      printf ("vsp = vsp + %ld", offset);
++	    }
++	}
++      else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
++	{
++	  unsigned int first, last;
++
++	  GET_OP (op2);
++	  first = op2 >> 4;
++	  last = op2 & 0x0f;
++	  if (op == 0xc8)
++	    first = first + 16;
++	  printf ("pop {D%d", first);
++	  if (last)
++	    printf ("-D%d", first + last);
++	  printf ("}");
++	}
++      else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
++	{
++	  unsigned int count = op & 0x07;
++
++	  printf ("pop {D8");
++	  if (count)
++	    printf ("-D%d", 8 + count);
++	  printf ("}");
++	}
++      else if (op >= 0xc0 && op <= 0xc5)
++	{
++	  unsigned int count = op & 0x07;
++
++	  printf ("     pop {wR10");
++	  if (count)
++	    printf ("-wR%d", 10 + count);
++	  printf ("}");
++	}
++      else if (op == 0xc6)
++	{
++	  unsigned int first, last;
++
++	  GET_OP (op2);
++	  first = op2 >> 4;
++	  last = op2 & 0x0f;
++	  printf ("pop {wR%d", first);
++	  if (last)
++	    printf ("-wR%d", first + last);
++	  printf ("}");
++	}
++      else if (op == 0xc7)
++	{
++	  GET_OP (op2);
++	  if (op2 == 0 || (op2 & 0xf0) != 0)
++	    printf (_("[Spare]"));
++	  else
++	    {
++	      unsigned int mask = op2 & 0x0f;
++	      bool first = true;
++	      int i;
++
++	      printf ("pop {");
++	      for (i = 0; i < 4; i++)
++		if (mask & (1 << i))
++		  {
++		    if (first)
++		      first = false;
++		    else
++		      printf (", ");
++		    printf ("wCGR%d", i);
++		  }
++	      printf ("}");
++	    }
++	}
++      else
++	{
++	  printf (_("     [unsupported opcode]"));
++	  res = false;
++	}
++
++      printf ("\n");
++    }
++
++  return res;
++}
++
++static bool
++decode_tic6x_unwind_bytecode (Filedata *                 filedata,
++			      struct arm_unw_aux_info *  aux,
++			      unsigned int               word,
++			      unsigned int               remaining,
++			      unsigned int               more_words,
++			      bfd_vma                    data_offset,
++			      Elf_Internal_Shdr *        data_sec,
++			      struct arm_section *       data_arm_sec)
++{
++  struct absaddr addr;
++
++  /* Decode the unwinding instructions.  */
++  while (1)
++    {
++      unsigned int op, op2;
++
++      ADVANCE;
++      if (remaining == 0)
++	break;
++      remaining--;
++      op = word >> 24;
++      word <<= 8;
++
++      printf ("  0x%02x ", op);
++
++      if ((op & 0xc0) == 0x00)
++	{
++	  int offset = ((op & 0x3f) << 3) + 8;
++	  printf ("     sp = sp + %d", offset);
++	}
++      else if ((op & 0xc0) == 0x80)
++	{
++	  GET_OP (op2);
++	  if (op == 0x80 && op2 == 0)
++	    printf (_("Refuse to unwind"));
++	  else
++	    {
++	      unsigned int mask = ((op & 0x1f) << 8) | op2;
++	      if (op & 0x20)
++		printf ("pop compact {");
++	      else
++		printf ("pop {");
++
++	      decode_tic6x_unwind_regmask (mask);
++	      printf("}");
++	    }
++	}
++      else if ((op & 0xf0) == 0xc0)
++	{
++	  unsigned int reg;
++	  unsigned int nregs;
++	  unsigned int i;
++	  const char *name;
++	  struct
++	  {
++	    unsigned int offset;
++	    unsigned int reg;
++	  } regpos[16];
++
++	  /* Scan entire instruction first so that GET_OP output is not
++	     interleaved with disassembly.  */
++	  nregs = 0;
++	  for (i = 0; nregs < (op & 0xf); i++)
++	    {
++	      GET_OP (op2);
++	      reg = op2 >> 4;
++	      if (reg != 0xf)
++		{
++		  regpos[nregs].offset = i * 2;
++		  regpos[nregs].reg = reg;
++		  nregs++;
++		}
++
++	      reg = op2 & 0xf;
++	      if (reg != 0xf)
++		{
++		  regpos[nregs].offset = i * 2 + 1;
++		  regpos[nregs].reg = reg;
++		  nregs++;
++		}
++	    }
++
++	  printf (_("pop frame {"));
++	  if (nregs == 0)
++	    {
++	      printf (_("*corrupt* - no registers specified"));
++	    }
++	  else
++	    {
++	      reg = nregs - 1;
++	      for (i = i * 2; i > 0; i--)
++		{
++		  if (regpos[reg].offset == i - 1)
++		    {
++		      name = tic6x_unwind_regnames[regpos[reg].reg];
++		      if (reg > 0)
++			reg--;
++		    }
++		  else
++		    name = _("[pad]");
++
++		  fputs (name, stdout);
++		  if (i > 1)
++		    printf (", ");
++		}
++	    }
++
++	  printf ("}");
++	}
++      else if (op == 0xd0)
++	printf ("     MOV FP, SP");
++      else if (op == 0xd1)
++	printf ("     __c6xabi_pop_rts");
++      else if (op == 0xd2)
++	{
++	  unsigned char buf[9];
++	  unsigned int i, len;
++	  unsigned long offset;
++
++	  for (i = 0; i < sizeof (buf); i++)
++	    {
++	      GET_OP (buf[i]);
++	      if ((buf[i] & 0x80) == 0)
++		break;
++	    }
++	  /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
++	  if (i == sizeof (buf))
++	    {
++	      warn (_("Corrupt stack pointer adjustment detected\n"));
++	      return false;
++	    }
++
++	  offset = read_leb128 (buf, buf + i + 1, false, &len, NULL);
++	  assert (len == i + 1);
++	  offset = offset * 8 + 0x408;
++	  printf (_("sp = sp + %ld"), offset);
++	}
++      else if ((op & 0xf0) == 0xe0)
++	{
++	  if ((op & 0x0f) == 7)
++	    printf ("     RETURN");
++	  else
++	    printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
++	}
++      else
++	{
++	  printf (_("     [unsupported opcode]"));
++	}
++      putchar ('\n');
++    }
++
++  return true;
++}
++
++static bfd_vma
++arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
++{
++  bfd_vma offset;
++
++  offset = word & 0x7fffffff;
++  if (offset & 0x40000000)
++    offset |= ~ (bfd_vma) 0x7fffffff;
++
++  if (filedata->file_header.e_machine == EM_TI_C6000)
++    offset <<= 1;
++
++  return offset + where;
++}
++
++static bool
++decode_arm_unwind (Filedata *                 filedata,
++		   struct arm_unw_aux_info *  aux,
++		   unsigned int               word,
++		   unsigned int               remaining,
++		   bfd_vma                    data_offset,
++		   Elf_Internal_Shdr *        data_sec,
++		   struct arm_section *       data_arm_sec)
++{
++  int per_index;
++  unsigned int more_words = 0;
++  struct absaddr addr;
++  bfd_vma sym_name = (bfd_vma) -1;
++  bool res = true;
++
++  if (remaining == 0)
++    {
++      /* Fetch the first word.
++	 Note - when decoding an object file the address extracted
++	 here will always be 0.  So we also pass in the sym_name
++	 parameter so that we can find the symbol associated with
++	 the personality routine.  */
++      if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
++				     & word, & addr, & sym_name))
++	return false;
++
++      remaining = 4;
++    }
++  else
++    {
++      addr.section = SHN_UNDEF;
++      addr.offset = 0;
++    }
++
++  if ((word & 0x80000000) == 0)
++    {
++      /* Expand prel31 for personality routine.  */
++      bfd_vma fn;
++      const char *procname;
++
++      fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
++      printf (_("  Personality routine: "));
++      if (fn == 0
++	  && addr.section == SHN_UNDEF && addr.offset == 0
++	  && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
++	{
++	  procname = aux->strtab + sym_name;
++	  print_vma (fn, PREFIX_HEX);
++	  if (procname)
++	    {
++	      fputs (" <", stdout);
++	      fputs (procname, stdout);
++	      fputc ('>', stdout);
++	    }
++	}
++      else
++	procname = arm_print_vma_and_name (filedata, aux, fn, addr);
++      fputc ('\n', stdout);
++
++      /* The GCC personality routines use the standard compact
++	 encoding, starting with one byte giving the number of
++	 words.  */
++      if (procname != NULL
++	  && (startswith (procname, "__gcc_personality_v0")
++	      || startswith (procname, "__gxx_personality_v0")
++	      || startswith (procname, "__gcj_personality_v0")
++	      || startswith (procname, "__gnu_objc_personality_v0")))
++	{
++	  remaining = 0;
++	  more_words = 1;
++	  ADVANCE;
++	  if (!remaining)
++	    {
++	      printf (_("  [Truncated data]\n"));
++	      return false;
++	    }
++	  more_words = word >> 24;
++	  word <<= 8;
++	  remaining--;
++	  per_index = -1;
++	}
++      else
++	return true;
++    }
++  else
++    {
++      /* ARM EHABI Section 6.3:
++
++	 An exception-handling table entry for the compact model looks like:
++
++           31 30-28 27-24 23-0
++	   -- ----- ----- ----
++            1   0   index Data for personalityRoutine[index]    */
++
++      if (filedata->file_header.e_machine == EM_ARM
++	  && (word & 0x70000000))
++	{
++	  warn (_("Corrupt ARM compact model table entry: %x \n"), word);
++	  res = false;
++	}
++
++      per_index = (word >> 24) & 0x7f;
++      printf (_("  Compact model index: %d\n"), per_index);
++      if (per_index == 0)
++	{
++	  more_words = 0;
++	  word <<= 8;
++	  remaining--;
++	}
++      else if (per_index < 3)
++	{
++	  more_words = (word >> 16) & 0xff;
++	  word <<= 16;
++	  remaining -= 2;
++	}
++    }
++
++  switch (filedata->file_header.e_machine)
++    {
++    case EM_ARM:
++      if (per_index < 3)
++	{
++	  if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
++					    data_offset, data_sec, data_arm_sec))
++	    res = false;
++	}
++      else
++	{
++	  warn (_("Unknown ARM compact model index encountered\n"));
++	  printf (_("  [reserved]\n"));
++	  res = false;
++	}
++      break;
++
++    case EM_TI_C6000:
++      if (per_index < 3)
++	{
++	  if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
++					      data_offset, data_sec, data_arm_sec))
++	    res = false;
++	}
++      else if (per_index < 5)
++	{
++	  if (((word >> 17) & 0x7f) == 0x7f)
++	    printf (_("  Restore stack from frame pointer\n"));
++	  else
++	    printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
++	  printf (_("  Registers restored: "));
++	  if (per_index == 4)
++	    printf (" (compact) ");
++	  decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
++	  putchar ('\n');
++	  printf (_("  Return register: %s\n"),
++		  tic6x_unwind_regnames[word & 0xf]);
++	}
++      else
++	printf (_("  [reserved (%d)]\n"), per_index);
++      break;
++
++    default:
++      error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
++	     filedata->file_header.e_machine);
++      res = false;
++    }
++
++  /* Decode the descriptors.  Not implemented.  */
++
++  return res;
++}
++
++static bool
++dump_arm_unwind (Filedata *                 filedata,
++		 struct arm_unw_aux_info *  aux,
++		 Elf_Internal_Shdr *        exidx_sec)
++{
++  struct arm_section exidx_arm_sec, extab_arm_sec;
++  unsigned int i, exidx_len;
++  unsigned long j, nfuns;
++  bool res = true;
++
++  memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
++  memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
++  exidx_len = exidx_sec->sh_size / 8;
++
++  aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
++  for (nfuns = 0, j = 0; j < aux->nsyms; j++)
++    if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
++      aux->funtab[nfuns++] = aux->symtab[j];
++  aux->nfuns = nfuns;
++  qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
++
++  for (i = 0; i < exidx_len; i++)
++    {
++      unsigned int exidx_fn, exidx_entry;
++      struct absaddr fn_addr, entry_addr;
++      bfd_vma fn;
++
++      fputc ('\n', stdout);
++
++      if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
++				     8 * i, & exidx_fn, & fn_addr, NULL)
++	  || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
++					8 * i + 4, & exidx_entry, & entry_addr, NULL))
++	{
++	  free (aux->funtab);
++	  arm_free_section (& exidx_arm_sec);
++	  arm_free_section (& extab_arm_sec);
++	  return false;
++	}
++
++      /* ARM EHABI, Section 5:
++	 An index table entry consists of 2 words.
++         The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
++      if (exidx_fn & 0x80000000)
++	{
++	  warn (_("corrupt index table entry: %x\n"), exidx_fn);
++	  res = false;
++	}
++
++      fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
++
++      arm_print_vma_and_name (filedata, aux, fn, fn_addr);
++      fputs (": ", stdout);
++
++      if (exidx_entry == 1)
++	{
++	  print_vma (exidx_entry, PREFIX_HEX);
++	  fputs (" [cantunwind]\n", stdout);
++	}
++      else if (exidx_entry & 0x80000000)
++	{
++	  print_vma (exidx_entry, PREFIX_HEX);
++	  fputc ('\n', stdout);
++	  decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
++	}
++      else
++	{
++	  bfd_vma table, table_offset = 0;
++	  Elf_Internal_Shdr *table_sec;
++
++	  fputs ("@", stdout);
++	  table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
++	  print_vma (table, PREFIX_HEX);
++	  printf ("\n");
++
++	  /* Locate the matching .ARM.extab.  */
++	  if (entry_addr.section != SHN_UNDEF
++	      && entry_addr.section < filedata->file_header.e_shnum)
++	    {
++	      table_sec = filedata->section_headers + entry_addr.section;
++	      table_offset = entry_addr.offset;
++	      /* PR 18879 */
++	      if (table_offset > table_sec->sh_size
++		  || ((bfd_signed_vma) table_offset) < 0)
++		{
++		  warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
++			(unsigned long) table_offset,
++			printable_section_name (filedata, table_sec));
++		  res = false;
++		  continue;
++		}
++	    }
++	  else
++	    {
++	      table_sec = find_section_by_address (filedata, table);
++	      if (table_sec != NULL)
++		table_offset = table - table_sec->sh_addr;
++	    }
++
++	  if (table_sec == NULL)
++	    {
++	      warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
++		    (unsigned long) table);
++	      res = false;
++	      continue;
++	    }
++
++	  if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
++				   &extab_arm_sec))
++	    res = false;
++	}
++    }
++
++  printf ("\n");
++
++  free (aux->funtab);
++  arm_free_section (&exidx_arm_sec);
++  arm_free_section (&extab_arm_sec);
++
++  return res;
++}
++
++/* Used for both ARM and C6X unwinding tables.  */
++
++static bool
++arm_process_unwind (Filedata * filedata)
++{
++  struct arm_unw_aux_info aux;
++  Elf_Internal_Shdr *unwsec = NULL;
++  Elf_Internal_Shdr *sec;
++  unsigned long i;
++  unsigned int sec_type;
++  bool res = true;
++
++  switch (filedata->file_header.e_machine)
++    {
++    case EM_ARM:
++      sec_type = SHT_ARM_EXIDX;
++      break;
++
++    case EM_TI_C6000:
++      sec_type = SHT_C6000_UNWIND;
++      break;
++
++    default:
++      error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
++	     filedata->file_header.e_machine);
++      return false;
++    }
++
++  if (filedata->string_table == NULL)
++    return false;
++
++  memset (& aux, 0, sizeof (aux));
++  aux.filedata = filedata;
++
++  for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
++    {
++      if (sec->sh_type == SHT_SYMTAB)
++	{
++	  if (aux.symtab)
++	    {
++	      error (_("Multiple symbol tables encountered\n"));
++	      free (aux.symtab);
++	      aux.symtab = NULL;
++	      free (aux.strtab);
++	      aux.strtab = NULL;
++	    }
++	  if (!get_symtab (filedata, sec, &aux.symtab, &aux.nsyms,
++			   &aux.strtab, &aux.strtab_size))
++	    return false;
++	}
++      else if (sec->sh_type == sec_type)
++	unwsec = sec;
++    }
++
++  if (unwsec == NULL)
++    printf (_("\nThere are no unwind sections in this file.\n"));
++  else
++    for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
++      {
++	if (sec->sh_type == sec_type)
++	  {
++	    unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
++	    printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
++			      "contains %lu entry:\n",
++			      "\nUnwind section '%s' at offset 0x%lx "
++			      "contains %lu entries:\n",
++			      num_unwind),
++		    printable_section_name (filedata, sec),
++		    (unsigned long) sec->sh_offset,
++		    num_unwind);
++
++	    if (! dump_arm_unwind (filedata, &aux, sec))
++	      res = false;
++	  }
++      }
++
++  free (aux.symtab);
++  free ((char *) aux.strtab);
++
++  return res;
++}
++
++static bool
++no_processor_specific_unwind (Filedata * filedata ATTRIBUTE_UNUSED)
++{
++  printf (_("No processor specific unwind information to decode\n"));
++  return true;
++}
++
++static bool
++process_unwind (Filedata * filedata)
++{
++  struct unwind_handler
++  {
++    unsigned int machtype;
++    bool (* handler)(Filedata *);
++  } handlers[] =
++  {
++    { EM_ARM, arm_process_unwind },
++    { EM_IA_64, ia64_process_unwind },
++    { EM_PARISC, hppa_process_unwind },
++    { EM_TI_C6000, arm_process_unwind },
++    { EM_386, no_processor_specific_unwind },
++    { EM_X86_64, no_processor_specific_unwind },
++    { 0, NULL }
++  };
++  int i;
++
++  if (!do_unwind)
++    return true;
++
++  for (i = 0; handlers[i].handler != NULL; i++)
++    if (filedata->file_header.e_machine == handlers[i].machtype)
++      return handlers[i].handler (filedata);
++
++  printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
++	  get_machine_name (filedata->file_header.e_machine));
++  return true;
++}
++
++static void
++dynamic_section_aarch64_val (Elf_Internal_Dyn * entry)
++{
++  switch (entry->d_tag)
++    {
++    case DT_AARCH64_BTI_PLT:
++    case DT_AARCH64_PAC_PLT:
++      break;
++    default:
++      print_vma (entry->d_un.d_ptr, PREFIX_HEX);
++      break;
++    }
++  putchar ('\n');
++}
++
++static void
++dynamic_section_mips_val (Filedata * filedata, Elf_Internal_Dyn * entry)
++{
++  switch (entry->d_tag)
++    {
++    case DT_MIPS_FLAGS:
++      if (entry->d_un.d_val == 0)
++	printf (_("NONE"));
++      else
++	{
++	  static const char * opts[] =
++	  {
++	    "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
++	    "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
++	    "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
++	    "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
++	    "RLD_ORDER_SAFE"
++	  };
++	  unsigned int cnt;
++	  bool first = true;
++
++	  for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
++	    if (entry->d_un.d_val & (1 << cnt))
++	      {
++		printf ("%s%s", first ? "" : " ", opts[cnt]);
++		first = false;
++	      }
++	}
++      break;
++
++    case DT_MIPS_IVERSION:
++      if (VALID_DYNAMIC_NAME (filedata, entry->d_un.d_val))
++	printf (_("Interface Version: %s"),
++		GET_DYNAMIC_NAME (filedata, entry->d_un.d_val));
++      else
++	{
++	  char buf[40];
++	  sprintf_vma (buf, entry->d_un.d_ptr);
++	  /* Note: coded this way so that there is a single string for translation.  */
++	  printf (_("<corrupt: %s>"), buf);
++	}
++      break;
++
++    case DT_MIPS_TIME_STAMP:
++      {
++	char timebuf[128];
++	struct tm * tmp;
++	time_t atime = entry->d_un.d_val;
++
++	tmp = gmtime (&atime);
++	/* PR 17531: file: 6accc532.  */
++	if (tmp == NULL)
++	  snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
++	else
++	  snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
++		    tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
++		    tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
++	printf (_("Time Stamp: %s"), timebuf);
++      }
++      break;
++
++    case DT_MIPS_RLD_VERSION:
++    case DT_MIPS_LOCAL_GOTNO:
++    case DT_MIPS_CONFLICTNO:
++    case DT_MIPS_LIBLISTNO:
++    case DT_MIPS_SYMTABNO:
++    case DT_MIPS_UNREFEXTNO:
++    case DT_MIPS_HIPAGENO:
++    case DT_MIPS_DELTA_CLASS_NO:
++    case DT_MIPS_DELTA_INSTANCE_NO:
++    case DT_MIPS_DELTA_RELOC_NO:
++    case DT_MIPS_DELTA_SYM_NO:
++    case DT_MIPS_DELTA_CLASSSYM_NO:
++    case DT_MIPS_COMPACT_SIZE:
++      print_vma (entry->d_un.d_val, DEC);
++      break;
++
++    case DT_MIPS_XHASH:
++      filedata->dynamic_info_DT_MIPS_XHASH = entry->d_un.d_val;
++      filedata->dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
++      /* Falls through.  */
++
++    default:
++      print_vma (entry->d_un.d_ptr, PREFIX_HEX);
++    }
++    putchar ('\n');
++}
++
++static void
++dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
++{
++  switch (entry->d_tag)
++    {
++    case DT_HP_DLD_FLAGS:
++      {
++	static struct
++	{
++	  long int bit;
++	  const char * str;
++	}
++	flags[] =
++	{
++	  { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
++	  { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
++	  { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
++	  { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
++	  { DT_HP_BIND_NOW, "HP_BIND_NOW" },
++	  { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
++	  { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
++	  { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
++	  { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
++	  { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
++	  { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
++	  { DT_HP_GST, "HP_GST" },
++	  { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
++	  { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
++	  { DT_HP_NODELETE, "HP_NODELETE" },
++	  { DT_HP_GROUP, "HP_GROUP" },
++	  { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
++	};
++	bool first = true;
++	size_t cnt;
++	bfd_vma val = entry->d_un.d_val;
++
++	for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
++	  if (val & flags[cnt].bit)
++	    {
++	      if (! first)
++		putchar (' ');
++	      fputs (flags[cnt].str, stdout);
++	      first = false;
++	      val ^= flags[cnt].bit;
++	    }
++
++	if (val != 0 || first)
++	  {
++	    if (! first)
++	      putchar (' ');
++	    print_vma (val, HEX);
++	  }
++      }
++      break;
++
++    default:
++      print_vma (entry->d_un.d_ptr, PREFIX_HEX);
++      break;
++    }
++  putchar ('\n');
++}
++
++#ifdef BFD64
++
++/* VMS vs Unix time offset and factor.  */
++
++#define VMS_EPOCH_OFFSET 35067168000000000LL
++#define VMS_GRANULARITY_FACTOR 10000000
++#ifndef INT64_MIN
++#define INT64_MIN (-9223372036854775807LL - 1)
++#endif
++
++/* Display a VMS time in a human readable format.  */
++
++static void
++print_vms_time (bfd_int64_t vmstime)
++{
++  struct tm *tm = NULL;
++  time_t unxtime;
++
++  if (vmstime >= INT64_MIN + VMS_EPOCH_OFFSET)
++    {
++      vmstime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
++      unxtime = vmstime;
++      if (unxtime == vmstime)
++	tm = gmtime (&unxtime);
++    }
++  if (tm != NULL)
++    printf ("%04u-%02u-%02uT%02u:%02u:%02u",
++	    tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
++	    tm->tm_hour, tm->tm_min, tm->tm_sec);
++}
++#endif /* BFD64 */
++
++static void
++dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
++{
++  switch (entry->d_tag)
++    {
++    case DT_IA_64_PLT_RESERVE:
++      /* First 3 slots reserved.  */
++      print_vma (entry->d_un.d_ptr, PREFIX_HEX);
++      printf (" -- ");
++      print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
++      break;
++
++    case DT_IA_64_VMS_LINKTIME:
++#ifdef BFD64
++      print_vms_time (entry->d_un.d_val);
++#endif
++      break;
++
++    case DT_IA_64_VMS_LNKFLAGS:
++      print_vma (entry->d_un.d_ptr, PREFIX_HEX);
++      if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
++        printf (" CALL_DEBUG");
++      if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
++        printf (" NOP0BUFS");
++      if (entry->d_un.d_val & VMS_LF_P0IMAGE)
++        printf (" P0IMAGE");
++      if (entry->d_un.d_val & VMS_LF_MKTHREADS)
++        printf (" MKTHREADS");
++      if (entry->d_un.d_val & VMS_LF_UPCALLS)
++        printf (" UPCALLS");
++      if (entry->d_un.d_val & VMS_LF_IMGSTA)
++        printf (" IMGSTA");
++      if (entry->d_un.d_val & VMS_LF_INITIALIZE)
++        printf (" INITIALIZE");
++      if (entry->d_un.d_val & VMS_LF_MAIN)
++        printf (" MAIN");
++      if (entry->d_un.d_val & VMS_LF_EXE_INIT)
++        printf (" EXE_INIT");
++      if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
++        printf (" TBK_IN_IMG");
++      if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
++        printf (" DBG_IN_IMG");
++      if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
++        printf (" TBK_IN_DSF");
++      if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
++        printf (" DBG_IN_DSF");
++      if (entry->d_un.d_val & VMS_LF_SIGNATURES)
++        printf (" SIGNATURES");
++      if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
++        printf (" REL_SEG_OFF");
++      break;
++
++    default:
++      print_vma (entry->d_un.d_ptr, PREFIX_HEX);
++      break;
++    }
++  putchar ('\n');
++}
++
++static bool
++get_32bit_dynamic_section (Filedata * filedata)
++{
++  Elf32_External_Dyn * edyn;
++  Elf32_External_Dyn * ext;
++  Elf_Internal_Dyn * entry;
++
++  edyn = (Elf32_External_Dyn *) get_data (NULL, filedata,
++					  filedata->dynamic_addr, 1,
++					  filedata->dynamic_size,
++					  _("dynamic section"));
++  if (!edyn)
++    return false;
++
++  /* SGI's ELF has more than one section in the DYNAMIC segment, and we
++     might not have the luxury of section headers.  Look for the DT_NULL
++     terminator to determine the number of entries.  */
++  for (ext = edyn, filedata->dynamic_nent = 0;
++       (char *) (ext + 1) <= (char *) edyn + filedata->dynamic_size;
++       ext++)
++    {
++      filedata->dynamic_nent++;
++      if (BYTE_GET (ext->d_tag) == DT_NULL)
++	break;
++    }
++
++  filedata->dynamic_section
++    = (Elf_Internal_Dyn *) cmalloc (filedata->dynamic_nent, sizeof (* entry));
++  if (filedata->dynamic_section == NULL)
++    {
++      error (_("Out of memory allocating space for %lu dynamic entries\n"),
++	     (unsigned long) filedata->dynamic_nent);
++      free (edyn);
++      return false;
++    }
++
++  for (ext = edyn, entry = filedata->dynamic_section;
++       entry < filedata->dynamic_section + filedata->dynamic_nent;
++       ext++, entry++)
++    {
++      entry->d_tag      = BYTE_GET (ext->d_tag);
++      entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
++    }
++
++  free (edyn);
++
++  return true;
++}
++
++static bool
++get_64bit_dynamic_section (Filedata * filedata)
++{
++  Elf64_External_Dyn * edyn;
++  Elf64_External_Dyn * ext;
++  Elf_Internal_Dyn * entry;
++
++  /* Read in the data.  */
++  edyn = (Elf64_External_Dyn *) get_data (NULL, filedata,
++					  filedata->dynamic_addr, 1,
++					  filedata->dynamic_size,
++					  _("dynamic section"));
++  if (!edyn)
++    return false;
++
++  /* SGI's ELF has more than one section in the DYNAMIC segment, and we
++     might not have the luxury of section headers.  Look for the DT_NULL
++     terminator to determine the number of entries.  */
++  for (ext = edyn, filedata->dynamic_nent = 0;
++       /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer.  */
++       (char *) (ext + 1) <= (char *) edyn + filedata->dynamic_size;
++       ext++)
++    {
++      filedata->dynamic_nent++;
++      if (BYTE_GET (ext->d_tag) == DT_NULL)
++	break;
++    }
++
++  filedata->dynamic_section
++    = (Elf_Internal_Dyn *) cmalloc (filedata->dynamic_nent, sizeof (* entry));
++  if (filedata->dynamic_section == NULL)
++    {
++      error (_("Out of memory allocating space for %lu dynamic entries\n"),
++	     (unsigned long) filedata->dynamic_nent);
++      free (edyn);
++      return false;
++    }
++
++  /* Convert from external to internal formats.  */
++  for (ext = edyn, entry = filedata->dynamic_section;
++       entry < filedata->dynamic_section + filedata->dynamic_nent;
++       ext++, entry++)
++    {
++      entry->d_tag      = BYTE_GET (ext->d_tag);
++      entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
++    }
++
++  free (edyn);
++
++  return true;
++}
++
++static bool
++get_dynamic_section (Filedata *filedata)
++{
++  if (filedata->dynamic_section)
++    return true;
++
++  if (is_32bit_elf)
++    return get_32bit_dynamic_section (filedata);
++  else
++    return get_64bit_dynamic_section (filedata);
++}
++
++static void
++print_dynamic_flags (bfd_vma flags)
++{
++  bool first = true;
++
++  while (flags)
++    {
++      bfd_vma flag;
++
++      flag = flags & - flags;
++      flags &= ~ flag;
++
++      if (first)
++	first = false;
++      else
++	putc (' ', stdout);
++
++      switch (flag)
++	{
++	case DF_ORIGIN:		fputs ("ORIGIN", stdout); break;
++	case DF_SYMBOLIC:	fputs ("SYMBOLIC", stdout); break;
++	case DF_TEXTREL:	fputs ("TEXTREL", stdout); break;
++	case DF_BIND_NOW:	fputs ("BIND_NOW", stdout); break;
++	case DF_STATIC_TLS:	fputs ("STATIC_TLS", stdout); break;
++	default:		fputs (_("unknown"), stdout); break;
++	}
++    }
++  puts ("");
++}
++
++static bfd_vma *
++get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
++{
++  unsigned char * e_data;
++  bfd_vma * i_data;
++
++  /* If the size_t type is smaller than the bfd_size_type, eg because
++     you are building a 32-bit tool on a 64-bit host, then make sure
++     that when (number) is cast to (size_t) no information is lost.  */
++  if (sizeof (size_t) < sizeof (bfd_size_type)
++      && (bfd_size_type) ((size_t) number) != number)
++    {
++      error (_("Size truncation prevents reading %s elements of size %u\n"),
++	     bfd_vmatoa ("u", number), ent_size);
++      return NULL;
++    }
++
++  /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
++     attempting to allocate memory when the read is bound to fail.  */
++  if (ent_size * number > filedata->file_size)
++    {
++      error (_("Invalid number of dynamic entries: %s\n"),
++	     bfd_vmatoa ("u", number));
++      return NULL;
++    }
++
++  e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
++  if (e_data == NULL)
++    {
++      error (_("Out of memory reading %s dynamic entries\n"),
++	     bfd_vmatoa ("u", number));
++      return NULL;
++    }
++
++  if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
++    {
++      error (_("Unable to read in %s bytes of dynamic data\n"),
++	     bfd_vmatoa ("u", number * ent_size));
++      free (e_data);
++      return NULL;
++    }
++
++  i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
++  if (i_data == NULL)
++    {
++      error (_("Out of memory allocating space for %s dynamic entries\n"),
++	     bfd_vmatoa ("u", number));
++      free (e_data);
++      return NULL;
++    }
++
++  while (number--)
++    i_data[number] = byte_get (e_data + number * ent_size, ent_size);
++
++  free (e_data);
++
++  return i_data;
++}
++
++static unsigned long
++get_num_dynamic_syms (Filedata * filedata)
++{
++  unsigned long num_of_syms = 0;
++
++  if (!do_histogram && (!do_using_dynamic || do_dyn_syms))
++    return num_of_syms;
++
++  if (filedata->dynamic_info[DT_HASH])
++    {
++      unsigned char nb[8];
++      unsigned char nc[8];
++      unsigned int hash_ent_size = 4;
++
++      if ((filedata->file_header.e_machine == EM_ALPHA
++	   || filedata->file_header.e_machine == EM_S390
++	   || filedata->file_header.e_machine == EM_S390_OLD)
++	  && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
++	hash_ent_size = 8;
++
++      if (fseek (filedata->handle,
++		 (filedata->archive_file_offset
++		  + offset_from_vma (filedata, filedata->dynamic_info[DT_HASH],
++				     sizeof nb + sizeof nc)),
++		 SEEK_SET))
++	{
++	  error (_("Unable to seek to start of dynamic information\n"));
++	  goto no_hash;
++	}
++
++      if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
++	{
++	  error (_("Failed to read in number of buckets\n"));
++	  goto no_hash;
++	}
++
++      if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
++	{
++	  error (_("Failed to read in number of chains\n"));
++	  goto no_hash;
++	}
++
++      filedata->nbuckets = byte_get (nb, hash_ent_size);
++      filedata->nchains = byte_get (nc, hash_ent_size);
++
++      if (filedata->nbuckets != 0 && filedata->nchains != 0)
++	{
++	  filedata->buckets = get_dynamic_data (filedata, filedata->nbuckets,
++						hash_ent_size);
++	  filedata->chains  = get_dynamic_data (filedata, filedata->nchains,
++						hash_ent_size);
++
++	  if (filedata->buckets != NULL && filedata->chains != NULL)
++	    num_of_syms = filedata->nchains;
++	}
++    no_hash:
++      if (num_of_syms == 0)
++	{
++	  free (filedata->buckets);
++	  filedata->buckets = NULL;
++	  free (filedata->chains);
++	  filedata->chains = NULL;
++	  filedata->nbuckets = 0;
++	}
++    }
++
++  if (filedata->dynamic_info_DT_GNU_HASH)
++    {
++      unsigned char nb[16];
++      bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
++      bfd_vma buckets_vma;
++      unsigned long hn;
++
++      if (fseek (filedata->handle,
++		 (filedata->archive_file_offset
++		  + offset_from_vma (filedata,
++				     filedata->dynamic_info_DT_GNU_HASH,
++				     sizeof nb)),
++		 SEEK_SET))
++	{
++	  error (_("Unable to seek to start of dynamic information\n"));
++	  goto no_gnu_hash;
++	}
++
++      if (fread (nb, 16, 1, filedata->handle) != 1)
++	{
++	  error (_("Failed to read in number of buckets\n"));
++	  goto no_gnu_hash;
++	}
++
++      filedata->ngnubuckets = byte_get (nb, 4);
++      filedata->gnusymidx = byte_get (nb + 4, 4);
++      bitmaskwords = byte_get (nb + 8, 4);
++      buckets_vma = filedata->dynamic_info_DT_GNU_HASH + 16;
++      if (is_32bit_elf)
++	buckets_vma += bitmaskwords * 4;
++      else
++	buckets_vma += bitmaskwords * 8;
++
++      if (fseek (filedata->handle,
++		 (filedata->archive_file_offset
++		  + offset_from_vma (filedata, buckets_vma, 4)),
++		 SEEK_SET))
++	{
++	  error (_("Unable to seek to start of dynamic information\n"));
++	  goto no_gnu_hash;
++	}
++
++      filedata->gnubuckets
++	= get_dynamic_data (filedata, filedata->ngnubuckets, 4);
++
++      if (filedata->gnubuckets == NULL)
++	goto no_gnu_hash;
++
++      for (i = 0; i < filedata->ngnubuckets; i++)
++	if (filedata->gnubuckets[i] != 0)
++	  {
++	    if (filedata->gnubuckets[i] < filedata->gnusymidx)
++	      goto no_gnu_hash;
++
++	    if (maxchain == 0xffffffff || filedata->gnubuckets[i] > maxchain)
++	      maxchain = filedata->gnubuckets[i];
++	  }
++
++      if (maxchain == 0xffffffff)
++	goto no_gnu_hash;
++
++      maxchain -= filedata->gnusymidx;
++
++      if (fseek (filedata->handle,
++		 (filedata->archive_file_offset
++		  + offset_from_vma (filedata,
++				     buckets_vma + 4 * (filedata->ngnubuckets
++							+ maxchain),
++				      4)),
++		 SEEK_SET))
++	{
++	  error (_("Unable to seek to start of dynamic information\n"));
++	  goto no_gnu_hash;
++	}
++
++      do
++	{
++	  if (fread (nb, 4, 1, filedata->handle) != 1)
++	    {
++	      error (_("Failed to determine last chain length\n"));
++	      goto no_gnu_hash;
++	    }
++
++	  if (maxchain + 1 == 0)
++	    goto no_gnu_hash;
++
++	  ++maxchain;
++	}
++      while ((byte_get (nb, 4) & 1) == 0);
++
++      if (fseek (filedata->handle,
++		 (filedata->archive_file_offset
++		  + offset_from_vma (filedata, (buckets_vma
++						+ 4 * filedata->ngnubuckets),
++				     4)),
++		 SEEK_SET))
++	{
++	  error (_("Unable to seek to start of dynamic information\n"));
++	  goto no_gnu_hash;
++	}
++
++      filedata->gnuchains = get_dynamic_data (filedata, maxchain, 4);
++      filedata->ngnuchains = maxchain;
++
++      if (filedata->gnuchains == NULL)
++	goto no_gnu_hash;
++
++      if (filedata->dynamic_info_DT_MIPS_XHASH)
++	{
++	  if (fseek (filedata->handle,
++		     (filedata->archive_file_offset
++		      + offset_from_vma (filedata, (buckets_vma
++						    + 4 * (filedata->ngnubuckets
++							   + maxchain)), 4)),
++		     SEEK_SET))
++	    {
++	      error (_("Unable to seek to start of dynamic information\n"));
++	      goto no_gnu_hash;
++	    }
++
++	  filedata->mipsxlat = get_dynamic_data (filedata, maxchain, 4);
++	  if (filedata->mipsxlat == NULL)
++	    goto no_gnu_hash;
++	}
++
++      for (hn = 0; hn < filedata->ngnubuckets; ++hn)
++	if (filedata->gnubuckets[hn] != 0)
++	  {
++	    bfd_vma si = filedata->gnubuckets[hn];
++	    bfd_vma off = si - filedata->gnusymidx;
++
++	    do
++	      {
++		if (filedata->dynamic_info_DT_MIPS_XHASH)
++		  {
++		    if (off < filedata->ngnuchains
++			&& filedata->mipsxlat[off] >= num_of_syms)
++		      num_of_syms = filedata->mipsxlat[off] + 1;
++		  }
++		else
++		  {
++		    if (si >= num_of_syms)
++		      num_of_syms = si + 1;
++		  }
++		si++;
++	      }
++	    while (off < filedata->ngnuchains
++		   && (filedata->gnuchains[off++] & 1) == 0);
++	  }
++
++      if (num_of_syms == 0)
++	{
++	no_gnu_hash:
++	  free (filedata->mipsxlat);
++	  filedata->mipsxlat = NULL;
++	  free (filedata->gnuchains);
++	  filedata->gnuchains = NULL;
++	  free (filedata->gnubuckets);
++	  filedata->gnubuckets = NULL;
++	  filedata->ngnubuckets = 0;
++	  filedata->ngnuchains = 0;
++	}
++    }
++
++  return num_of_syms;
++}
++
++/* Parse and display the contents of the dynamic section.  */
++
++static bool
++process_dynamic_section (Filedata * filedata)
++{
++  Elf_Internal_Dyn * entry;
++
++  if (filedata->dynamic_size <= 1)
++    {
++      if (do_dynamic)
++	{
++	  if (filedata->is_separate)
++	    printf (_("\nThere is no dynamic section in linked file '%s'.\n"),
++		    filedata->file_name);
++	  else
++	    printf (_("\nThere is no dynamic section in this file.\n"));
++	}
++
++      return true;
++    }
++
++  if (!get_dynamic_section (filedata))
++    return false;
++
++  /* Find the appropriate symbol table.  */
++  if (filedata->dynamic_symbols == NULL || do_histogram)
++    {
++      unsigned long num_of_syms;
++
++      for (entry = filedata->dynamic_section;
++	   entry < filedata->dynamic_section + filedata->dynamic_nent;
++	   ++entry)
++	if (entry->d_tag == DT_SYMTAB)
++	  filedata->dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
++	else if (entry->d_tag == DT_SYMENT)
++	  filedata->dynamic_info[DT_SYMENT] = entry->d_un.d_val;
++	else if (entry->d_tag == DT_HASH)
++	  filedata->dynamic_info[DT_HASH] = entry->d_un.d_val;
++	else if (entry->d_tag == DT_GNU_HASH)
++	  filedata->dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
++	else if ((filedata->file_header.e_machine == EM_MIPS
++		  || filedata->file_header.e_machine == EM_MIPS_RS3_LE)
++		 && entry->d_tag == DT_MIPS_XHASH)
++	  {
++	    filedata->dynamic_info_DT_MIPS_XHASH = entry->d_un.d_val;
++	    filedata->dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
++	  }
++
++      num_of_syms = get_num_dynamic_syms (filedata);
++
++      if (num_of_syms != 0
++	  && filedata->dynamic_symbols == NULL
++	  && filedata->dynamic_info[DT_SYMTAB]
++	  && filedata->dynamic_info[DT_SYMENT])
++	{
++	  Elf_Internal_Phdr *seg;
++	  bfd_vma vma = filedata->dynamic_info[DT_SYMTAB];
++
++	  if (! get_program_headers (filedata))
++	    {
++	      error (_("Cannot interpret virtual addresses "
++		       "without program headers.\n"));
++	      return false;
++	    }
++
++	  for (seg = filedata->program_headers;
++	       seg < filedata->program_headers + filedata->file_header.e_phnum;
++	       ++seg)
++	    {
++	      if (seg->p_type != PT_LOAD)
++		continue;
++
++	      if (seg->p_offset + seg->p_filesz > filedata->file_size)
++		{
++		  /* See PR 21379 for a reproducer.  */
++		  error (_("Invalid PT_LOAD entry\n"));
++		  return false;
++		}
++
++	      if (vma >= (seg->p_vaddr & -seg->p_align)
++		  && vma < seg->p_vaddr + seg->p_filesz)
++		{
++		  /* Since we do not know how big the symbol table is,
++		     we default to reading in up to the end of PT_LOAD
++		     segment and processing that.  This is overkill, I
++		     know, but it should work.  */
++		  Elf_Internal_Shdr section;
++		  section.sh_offset = (vma - seg->p_vaddr
++				       + seg->p_offset);
++		  section.sh_size = (num_of_syms
++				     * filedata->dynamic_info[DT_SYMENT]);
++		  section.sh_entsize = filedata->dynamic_info[DT_SYMENT];
++
++		  if (do_checks
++		      && filedata->dynamic_symtab_section != NULL
++		      && ((filedata->dynamic_symtab_section->sh_offset
++			   != section.sh_offset)
++			  || (filedata->dynamic_symtab_section->sh_size
++			      != section.sh_size)
++			  || (filedata->dynamic_symtab_section->sh_entsize
++			      != section.sh_entsize)))
++		    warn (_("\
++the .dynsym section doesn't match the DT_SYMTAB and DT_SYMENT tags\n"));
++
++		  section.sh_name = filedata->string_table_length;
++		  filedata->dynamic_symbols
++		    = get_elf_symbols (filedata, &section,
++				       &filedata->num_dynamic_syms);
++		  if (filedata->dynamic_symbols == NULL
++		      || filedata->num_dynamic_syms != num_of_syms)
++		    {
++		      error (_("Corrupt DT_SYMTAB dynamic entry\n"));
++		      return false;
++		    }
++		  break;
++		}
++	    }
++	}
++    }
++
++  /* Similarly find a string table.  */
++  if (filedata->dynamic_strings == NULL)
++    for (entry = filedata->dynamic_section;
++	 entry < filedata->dynamic_section + filedata->dynamic_nent;
++	 ++entry)
++      {
++	if (entry->d_tag == DT_STRTAB)
++	  filedata->dynamic_info[DT_STRTAB] = entry->d_un.d_val;
++
++	if (entry->d_tag == DT_STRSZ)
++	  filedata->dynamic_info[DT_STRSZ] = entry->d_un.d_val;
++
++	if (filedata->dynamic_info[DT_STRTAB]
++	    && filedata->dynamic_info[DT_STRSZ])
++	  {
++	    unsigned long offset;
++	    bfd_size_type str_tab_len = filedata->dynamic_info[DT_STRSZ];
++
++	    offset = offset_from_vma (filedata,
++				      filedata->dynamic_info[DT_STRTAB],
++				      str_tab_len);
++	    if (do_checks
++		&& filedata->dynamic_strtab_section
++		&& ((filedata->dynamic_strtab_section->sh_offset
++		     != (file_ptr) offset)
++		    || (filedata->dynamic_strtab_section->sh_size
++			!= str_tab_len)))
++	      warn (_("\
++the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n"));
++
++	    filedata->dynamic_strings
++	      = (char *) get_data (NULL, filedata, offset, 1, str_tab_len,
++				   _("dynamic string table"));
++	    if (filedata->dynamic_strings == NULL)
++	      {
++		error (_("Corrupt DT_STRTAB dynamic entry\n"));
++		break;
++	      }
++
++	    filedata->dynamic_strings_length = str_tab_len;
++	    break;
++	  }
++      }
++
++  /* And find the syminfo section if available.  */
++  if (filedata->dynamic_syminfo == NULL)
++    {
++      unsigned long syminsz = 0;
++
++      for (entry = filedata->dynamic_section;
++	   entry < filedata->dynamic_section + filedata->dynamic_nent;
++	   ++entry)
++	{
++	  if (entry->d_tag == DT_SYMINENT)
++	    {
++	      /* Note: these braces are necessary to avoid a syntax
++		 error from the SunOS4 C compiler.  */
++	      /* PR binutils/17531: A corrupt file can trigger this test.
++		 So do not use an assert, instead generate an error message.  */
++	      if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
++		error (_("Bad value (%d) for SYMINENT entry\n"),
++		       (int) entry->d_un.d_val);
++	    }
++	  else if (entry->d_tag == DT_SYMINSZ)
++	    syminsz = entry->d_un.d_val;
++	  else if (entry->d_tag == DT_SYMINFO)
++	    filedata->dynamic_syminfo_offset
++	      = offset_from_vma (filedata, entry->d_un.d_val, syminsz);
++	}
++
++      if (filedata->dynamic_syminfo_offset != 0 && syminsz != 0)
++	{
++	  Elf_External_Syminfo * extsyminfo;
++	  Elf_External_Syminfo * extsym;
++	  Elf_Internal_Syminfo * syminfo;
++
++	  /* There is a syminfo section.  Read the data.  */
++	  extsyminfo = (Elf_External_Syminfo *)
++	    get_data (NULL, filedata, filedata->dynamic_syminfo_offset,
++		      1, syminsz, _("symbol information"));
++	  if (!extsyminfo)
++	    return false;
++
++	  if (filedata->dynamic_syminfo != NULL)
++	    {
++	      error (_("Multiple dynamic symbol information sections found\n"));
++	      free (filedata->dynamic_syminfo);
++	    }
++	  filedata->dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
++	  if (filedata->dynamic_syminfo == NULL)
++	    {
++	      error (_("Out of memory allocating %lu bytes "
++		       "for dynamic symbol info\n"),
++		     (unsigned long) syminsz);
++	      return false;
++	    }
++
++	  filedata->dynamic_syminfo_nent
++	    = syminsz / sizeof (Elf_External_Syminfo);
++	  for (syminfo = filedata->dynamic_syminfo, extsym = extsyminfo;
++	       syminfo < (filedata->dynamic_syminfo
++			  + filedata->dynamic_syminfo_nent);
++	       ++syminfo, ++extsym)
++	    {
++	      syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
++	      syminfo->si_flags = BYTE_GET (extsym->si_flags);
++	    }
++
++	  free (extsyminfo);
++	}
++    }
++
++  if (do_dynamic && filedata->dynamic_addr)
++    {
++      if (filedata->dynamic_nent == 1)
++	{
++	  if (filedata->is_separate)
++	    printf (_("\nIn linked file '%s' the dynamic section at offset 0x%lx contains 1 entry:\n"),
++		    filedata->file_name,
++		    filedata->dynamic_addr);
++	  else
++	    printf (_("\nDynamic section at offset 0x%lx contains 1 entry:\n"),
++		    filedata->dynamic_addr);
++	}
++      else
++	{
++	  if (filedata->is_separate)
++	    printf (_("\nIn linked file '%s' the dynamic section at offset 0x%lx contains %lu entries:\n"),
++		    filedata->file_name,
++		    filedata->dynamic_addr,
++		    (unsigned long) filedata->dynamic_nent);
++	  else
++	    printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
++		    filedata->dynamic_addr,
++		    (unsigned long) filedata->dynamic_nent);
++	}
++    }
++  if (do_dynamic)
++    printf (_("  Tag        Type                         Name/Value\n"));
++
++  for (entry = filedata->dynamic_section;
++       entry < filedata->dynamic_section + filedata->dynamic_nent;
++       entry++)
++    {
++      if (do_dynamic)
++	{
++	  const char * dtype;
++
++	  putchar (' ');
++	  print_vma (entry->d_tag, FULL_HEX);
++	  dtype = get_dynamic_type (filedata, entry->d_tag);
++	  printf (" (%s)%*s", dtype,
++		  ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
++	}
++
++      switch (entry->d_tag)
++	{
++	case DT_FLAGS:
++	  if (do_dynamic)
++	    print_dynamic_flags (entry->d_un.d_val);
++	  break;
++
++	case DT_AUXILIARY:
++	case DT_FILTER:
++	case DT_CONFIG:
++	case DT_DEPAUDIT:
++	case DT_AUDIT:
++	  if (do_dynamic)
++	    {
++	      switch (entry->d_tag)
++		{
++		case DT_AUXILIARY:
++		  printf (_("Auxiliary library"));
++		  break;
++
++		case DT_FILTER:
++		  printf (_("Filter library"));
++		  break;
++
++		case DT_CONFIG:
++		  printf (_("Configuration file"));
++		  break;
++
++		case DT_DEPAUDIT:
++		  printf (_("Dependency audit library"));
++		  break;
++
++		case DT_AUDIT:
++		  printf (_("Audit library"));
++		  break;
++		}
++
++	      if (VALID_DYNAMIC_NAME (filedata, entry->d_un.d_val))
++		printf (": [%s]\n",
++			GET_DYNAMIC_NAME (filedata, entry->d_un.d_val));
++	      else
++		{
++		  printf (": ");
++		  print_vma (entry->d_un.d_val, PREFIX_HEX);
++		  putchar ('\n');
++		}
++	    }
++	  break;
++
++	case DT_FEATURE:
++	  if (do_dynamic)
++	    {
++	      printf (_("Flags:"));
++
++	      if (entry->d_un.d_val == 0)
++		printf (_(" None\n"));
++	      else
++		{
++		  unsigned long int val = entry->d_un.d_val;
++
++		  if (val & DTF_1_PARINIT)
++		    {
++		      printf (" PARINIT");
++		      val ^= DTF_1_PARINIT;
++		    }
++		  if (val & DTF_1_CONFEXP)
++		    {
++		      printf (" CONFEXP");
++		      val ^= DTF_1_CONFEXP;
++		    }
++		  if (val != 0)
++		    printf (" %lx", val);
++		  puts ("");
++		}
++	    }
++	  break;
++
++	case DT_POSFLAG_1:
++	  if (do_dynamic)
++	    {
++	      printf (_("Flags:"));
++
++	      if (entry->d_un.d_val == 0)
++		printf (_(" None\n"));
++	      else
++		{
++		  unsigned long int val = entry->d_un.d_val;
++
++		  if (val & DF_P1_LAZYLOAD)
++		    {
++		      printf (" LAZYLOAD");
++		      val ^= DF_P1_LAZYLOAD;
++		    }
++		  if (val & DF_P1_GROUPPERM)
++		    {
++		      printf (" GROUPPERM");
++		      val ^= DF_P1_GROUPPERM;
++		    }
++		  if (val != 0)
++		    printf (" %lx", val);
++		  puts ("");
++		}
++	    }
++	  break;
++
++	case DT_FLAGS_1:
++	  if (do_dynamic)
++	    {
++	      printf (_("Flags:"));
++	      if (entry->d_un.d_val == 0)
++		printf (_(" None\n"));
++	      else
++		{
++		  unsigned long int val = entry->d_un.d_val;
++
++		  if (val & DF_1_NOW)
++		    {
++		      printf (" NOW");
++		      val ^= DF_1_NOW;
++		    }
++		  if (val & DF_1_GLOBAL)
++		    {
++		      printf (" GLOBAL");
++		      val ^= DF_1_GLOBAL;
++		    }
++		  if (val & DF_1_GROUP)
++		    {
++		      printf (" GROUP");
++		      val ^= DF_1_GROUP;
++		    }
++		  if (val & DF_1_NODELETE)
++		    {
++		      printf (" NODELETE");
++		      val ^= DF_1_NODELETE;
++		    }
++		  if (val & DF_1_LOADFLTR)
++		    {
++		      printf (" LOADFLTR");
++		      val ^= DF_1_LOADFLTR;
++		    }
++		  if (val & DF_1_INITFIRST)
++		    {
++		      printf (" INITFIRST");
++		      val ^= DF_1_INITFIRST;
++		    }
++		  if (val & DF_1_NOOPEN)
++		    {
++		      printf (" NOOPEN");
++		      val ^= DF_1_NOOPEN;
++		    }
++		  if (val & DF_1_ORIGIN)
++		    {
++		      printf (" ORIGIN");
++		      val ^= DF_1_ORIGIN;
++		    }
++		  if (val & DF_1_DIRECT)
++		    {
++		      printf (" DIRECT");
++		      val ^= DF_1_DIRECT;
++		    }
++		  if (val & DF_1_TRANS)
++		    {
++		      printf (" TRANS");
++		      val ^= DF_1_TRANS;
++		    }
++		  if (val & DF_1_INTERPOSE)
++		    {
++		      printf (" INTERPOSE");
++		      val ^= DF_1_INTERPOSE;
++		    }
++		  if (val & DF_1_NODEFLIB)
++		    {
++		      printf (" NODEFLIB");
++		      val ^= DF_1_NODEFLIB;
++		    }
++		  if (val & DF_1_NODUMP)
++		    {
++		      printf (" NODUMP");
++		      val ^= DF_1_NODUMP;
++		    }
++		  if (val & DF_1_CONFALT)
++		    {
++		      printf (" CONFALT");
++		      val ^= DF_1_CONFALT;
++		    }
++		  if (val & DF_1_ENDFILTEE)
++		    {
++		      printf (" ENDFILTEE");
++		      val ^= DF_1_ENDFILTEE;
++		    }
++		  if (val & DF_1_DISPRELDNE)
++		    {
++		      printf (" DISPRELDNE");
++		      val ^= DF_1_DISPRELDNE;
++		    }
++		  if (val & DF_1_DISPRELPND)
++		    {
++		      printf (" DISPRELPND");
++		      val ^= DF_1_DISPRELPND;
++		    }
++		  if (val & DF_1_NODIRECT)
++		    {
++		      printf (" NODIRECT");
++		      val ^= DF_1_NODIRECT;
++		    }
++		  if (val & DF_1_IGNMULDEF)
++		    {
++		      printf (" IGNMULDEF");
++		      val ^= DF_1_IGNMULDEF;
++		    }
++		  if (val & DF_1_NOKSYMS)
++		    {
++		      printf (" NOKSYMS");
++		      val ^= DF_1_NOKSYMS;
++		    }
++		  if (val & DF_1_NOHDR)
++		    {
++		      printf (" NOHDR");
++		      val ^= DF_1_NOHDR;
++		    }
++		  if (val & DF_1_EDITED)
++		    {
++		      printf (" EDITED");
++		      val ^= DF_1_EDITED;
++		    }
++		  if (val & DF_1_NORELOC)
++		    {
++		      printf (" NORELOC");
++		      val ^= DF_1_NORELOC;
++		    }
++		  if (val & DF_1_SYMINTPOSE)
++		    {
++		      printf (" SYMINTPOSE");
++		      val ^= DF_1_SYMINTPOSE;
++		    }
++		  if (val & DF_1_GLOBAUDIT)
++		    {
++		      printf (" GLOBAUDIT");
++		      val ^= DF_1_GLOBAUDIT;
++		    }
++		  if (val & DF_1_SINGLETON)
++		    {
++		      printf (" SINGLETON");
++		      val ^= DF_1_SINGLETON;
++		    }
++		  if (val & DF_1_STUB)
++		    {
++		      printf (" STUB");
++		      val ^= DF_1_STUB;
++		    }
++		  if (val & DF_1_PIE)
++		    {
++		      printf (" PIE");
++		      val ^= DF_1_PIE;
++		    }
++		  if (val & DF_1_KMOD)
++		    {
++		      printf (" KMOD");
++		      val ^= DF_1_KMOD;
++		    }
++		  if (val & DF_1_WEAKFILTER)
++		    {
++		      printf (" WEAKFILTER");
++		      val ^= DF_1_WEAKFILTER;
++		    }
++		  if (val & DF_1_NOCOMMON)
++		    {
++		      printf (" NOCOMMON");
++		      val ^= DF_1_NOCOMMON;
++		    }
++		  if (val != 0)
++		    printf (" %lx", val);
++		  puts ("");
++		}
++	    }
++	  break;
++
++	case DT_PLTREL:
++	  filedata->dynamic_info[entry->d_tag] = entry->d_un.d_val;
++	  if (do_dynamic)
++	    puts (get_dynamic_type (filedata, entry->d_un.d_val));
++	  break;
++
++	case DT_NULL	:
++	case DT_NEEDED	:
++	case DT_PLTGOT	:
++	case DT_HASH	:
++	case DT_STRTAB	:
++	case DT_SYMTAB	:
++	case DT_RELA	:
++	case DT_INIT	:
++	case DT_FINI	:
++	case DT_SONAME	:
++	case DT_RPATH	:
++	case DT_SYMBOLIC:
++	case DT_REL	:
++	case DT_DEBUG	:
++	case DT_TEXTREL	:
++	case DT_JMPREL	:
++	case DT_RUNPATH	:
++	  filedata->dynamic_info[entry->d_tag] = entry->d_un.d_val;
++
++	  if (do_dynamic)
++	    {
++	      char * name;
++
++	      if (VALID_DYNAMIC_NAME (filedata, entry->d_un.d_val))
++		name = GET_DYNAMIC_NAME (filedata, entry->d_un.d_val);
++	      else
++		name = NULL;
++
++	      if (name)
++		{
++		  switch (entry->d_tag)
++		    {
++		    case DT_NEEDED:
++		      printf (_("Shared library: [%s]"), name);
++
++		      if (filedata->program_interpreter
++			  && streq (name, filedata->program_interpreter))
++			printf (_(" program interpreter"));
++		      break;
++
++		    case DT_SONAME:
++		      printf (_("Library soname: [%s]"), name);
++		      break;
++
++		    case DT_RPATH:
++		      printf (_("Library rpath: [%s]"), name);
++		      break;
++
++		    case DT_RUNPATH:
++		      printf (_("Library runpath: [%s]"), name);
++		      break;
++
++		    default:
++		      print_vma (entry->d_un.d_val, PREFIX_HEX);
++		      break;
++		    }
++		}
++	      else
++		print_vma (entry->d_un.d_val, PREFIX_HEX);
++
++	      putchar ('\n');
++	    }
++	  break;
++
++	case DT_PLTRELSZ:
++	case DT_RELASZ	:
++	case DT_STRSZ	:
++	case DT_RELSZ	:
++	case DT_RELAENT	:
++	case DT_SYMENT	:
++	case DT_RELENT	:
++	  filedata->dynamic_info[entry->d_tag] = entry->d_un.d_val;
++	  /* Fall through.  */
++	case DT_PLTPADSZ:
++	case DT_MOVEENT	:
++	case DT_MOVESZ	:
++	case DT_INIT_ARRAYSZ:
++	case DT_FINI_ARRAYSZ:
++	case DT_GNU_CONFLICTSZ:
++	case DT_GNU_LIBLISTSZ:
++	  if (do_dynamic)
++	    {
++	      print_vma (entry->d_un.d_val, UNSIGNED);
++	      printf (_(" (bytes)\n"));
++	    }
++	  break;
++
++	case DT_VERDEFNUM:
++	case DT_VERNEEDNUM:
++	case DT_RELACOUNT:
++	case DT_RELCOUNT:
++	  if (do_dynamic)
++	    {
++	      print_vma (entry->d_un.d_val, UNSIGNED);
++	      putchar ('\n');
++	    }
++	  break;
++
++	case DT_SYMINSZ:
++	case DT_SYMINENT:
++	case DT_SYMINFO:
++	case DT_USED:
++	case DT_INIT_ARRAY:
++	case DT_FINI_ARRAY:
++	  if (do_dynamic)
++	    {
++	      if (entry->d_tag == DT_USED
++		  && VALID_DYNAMIC_NAME (filedata, entry->d_un.d_val))
++		{
++		  char * name = GET_DYNAMIC_NAME (filedata, entry->d_un.d_val);
++
++		  if (*name)
++		    {
++		      printf (_("Not needed object: [%s]\n"), name);
++		      break;
++		    }
++		}
++
++	      print_vma (entry->d_un.d_val, PREFIX_HEX);
++	      putchar ('\n');
++	    }
++	  break;
++
++	case DT_BIND_NOW:
++	  /* The value of this entry is ignored.  */
++	  if (do_dynamic)
++	    putchar ('\n');
++	  break;
++
++	case DT_GNU_PRELINKED:
++	  if (do_dynamic)
++	    {
++	      struct tm * tmp;
++	      time_t atime = entry->d_un.d_val;
++
++	      tmp = gmtime (&atime);
++	      /* PR 17533 file: 041-1244816-0.004.  */
++	      if (tmp == NULL)
++		printf (_("<corrupt time val: %lx"),
++			(unsigned long) atime);
++	      else
++		printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
++			tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
++			tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
++
++	    }
++	  break;
++
++	case DT_GNU_HASH:
++	  filedata->dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
++	  if (do_dynamic)
++	    {
++	      print_vma (entry->d_un.d_val, PREFIX_HEX);
++	      putchar ('\n');
++	    }
++	  break;
++
++	case DT_GNU_FLAGS_1:
++	  if (do_dynamic)
++	    {
++	      printf (_("Flags:"));
++	      if (entry->d_un.d_val == 0)
++		printf (_(" None\n"));
++	      else
++		{
++		  unsigned long int val = entry->d_un.d_val;
++
++		  if (val & DF_GNU_1_UNIQUE)
++		    {
++		      printf (" UNIQUE");
++		      val ^= DF_GNU_1_UNIQUE;
++		    }
++		  if (val != 0)
++		    printf (" %lx", val);
++		  puts ("");
++		}
++	    }
++	  break;
++
++	default:
++	  if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
++	    filedata->version_info[DT_VERSIONTAGIDX (entry->d_tag)]
++	      = entry->d_un.d_val;
++
++	  if (do_dynamic)
++	    {
++	      switch (filedata->file_header.e_machine)
++		{
++		case EM_AARCH64:
++		  dynamic_section_aarch64_val (entry);
++		  break;
++		case EM_MIPS:
++		case EM_MIPS_RS3_LE:
++		  dynamic_section_mips_val (filedata, entry);
++		  break;
++		case EM_PARISC:
++		  dynamic_section_parisc_val (entry);
++		  break;
++		case EM_IA_64:
++		  dynamic_section_ia64_val (entry);
++		  break;
++		default:
++		  print_vma (entry->d_un.d_val, PREFIX_HEX);
++		  putchar ('\n');
++		}
++	    }
++	  break;
++	}
++    }
++
++  return true;
++}
++
++static char *
++get_ver_flags (unsigned int flags)
++{
++  static char buff[128];
++
++  buff[0] = 0;
++
++  if (flags == 0)
++    return _("none");
++
++  if (flags & VER_FLG_BASE)
++    strcat (buff, "BASE");
++
++  if (flags & VER_FLG_WEAK)
++    {
++      if (flags & VER_FLG_BASE)
++	strcat (buff, " | ");
++
++      strcat (buff, "WEAK");
++    }
++
++  if (flags & VER_FLG_INFO)
++    {
++      if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
++	strcat (buff, " | ");
++
++      strcat (buff, "INFO");
++    }
++
++  if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
++    {
++      if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
++	strcat (buff, " | ");
++
++      strcat (buff, _("<unknown>"));
++    }
++
++  return buff;
++}
++
++/* Display the contents of the version sections.  */
++
++static bool
++process_version_sections (Filedata * filedata)
++{
++  Elf_Internal_Shdr * section;
++  unsigned i;
++  bool found = false;
++
++  if (! do_version)
++    return true;
++
++  for (i = 0, section = filedata->section_headers;
++       i < filedata->file_header.e_shnum;
++       i++, section++)
++    {
++      switch (section->sh_type)
++	{
++	case SHT_GNU_verdef:
++	  {
++	    Elf_External_Verdef * edefs;
++	    unsigned long idx;
++	    unsigned long cnt;
++	    char * endbuf;
++
++	    found = true;
++
++	    if (filedata->is_separate)
++	      printf (ngettext ("\nIn linked file '%s' the version definition section '%s' contains %u entry:\n",
++				"\nIn linked file '%s' the version definition section '%s' contains %u entries:\n",
++				section->sh_info),
++		      filedata->file_name,
++		      printable_section_name (filedata, section),
++		      section->sh_info);
++	    else
++	      printf (ngettext ("\nVersion definition section '%s' "
++				"contains %u entry:\n",
++				"\nVersion definition section '%s' "
++				"contains %u entries:\n",
++				section->sh_info),
++		      printable_section_name (filedata, section),
++		      section->sh_info);
++
++	    printf (_(" Addr: 0x"));
++	    printf_vma (section->sh_addr);
++	    printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
++		    (unsigned long) section->sh_offset, section->sh_link,
++		    printable_section_name_from_index (filedata, section->sh_link));
++
++	    edefs = (Elf_External_Verdef *)
++                get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
++                          _("version definition section"));
++	    if (!edefs)
++	      break;
++	    endbuf = (char *) edefs + section->sh_size;
++
++	    for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
++	      {
++		char * vstart;
++		Elf_External_Verdef * edef;
++		Elf_Internal_Verdef ent;
++		Elf_External_Verdaux * eaux;
++		Elf_Internal_Verdaux aux;
++		unsigned long isum;
++		int j;
++
++		vstart = ((char *) edefs) + idx;
++		if (vstart + sizeof (*edef) > endbuf)
++		  break;
++
++		edef = (Elf_External_Verdef *) vstart;
++
++		ent.vd_version = BYTE_GET (edef->vd_version);
++		ent.vd_flags   = BYTE_GET (edef->vd_flags);
++		ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
++		ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
++		ent.vd_hash    = BYTE_GET (edef->vd_hash);
++		ent.vd_aux     = BYTE_GET (edef->vd_aux);
++		ent.vd_next    = BYTE_GET (edef->vd_next);
++
++		printf (_("  %#06lx: Rev: %d  Flags: %s"),
++			idx, ent.vd_version, get_ver_flags (ent.vd_flags));
++
++		printf (_("  Index: %d  Cnt: %d  "),
++			ent.vd_ndx, ent.vd_cnt);
++
++		/* Check for overflow.  */
++		if (ent.vd_aux > (size_t) (endbuf - vstart))
++		  break;
++
++		vstart += ent.vd_aux;
++
++		if (vstart + sizeof (*eaux) > endbuf)
++		  break;
++		eaux = (Elf_External_Verdaux *) vstart;
++
++		aux.vda_name = BYTE_GET (eaux->vda_name);
++		aux.vda_next = BYTE_GET (eaux->vda_next);
++
++		if (VALID_DYNAMIC_NAME (filedata, aux.vda_name))
++		  printf (_("Name: %s\n"),
++			  GET_DYNAMIC_NAME (filedata, aux.vda_name));
++		else
++		  printf (_("Name index: %ld\n"), aux.vda_name);
++
++		isum = idx + ent.vd_aux;
++
++		for (j = 1; j < ent.vd_cnt; j++)
++		  {
++		    if (aux.vda_next < sizeof (*eaux)
++			&& !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
++		      {
++			warn (_("Invalid vda_next field of %lx\n"),
++			      aux.vda_next);
++			j = ent.vd_cnt;
++			break;
++		      }
++		    /* Check for overflow.  */
++		    if (aux.vda_next > (size_t) (endbuf - vstart))
++		      break;
++
++		    isum   += aux.vda_next;
++		    vstart += aux.vda_next;
++
++		    if (vstart + sizeof (*eaux) > endbuf)
++		      break;
++		    eaux = (Elf_External_Verdaux *) vstart;
++
++		    aux.vda_name = BYTE_GET (eaux->vda_name);
++		    aux.vda_next = BYTE_GET (eaux->vda_next);
++
++		    if (VALID_DYNAMIC_NAME (filedata, aux.vda_name))
++		      printf (_("  %#06lx: Parent %d: %s\n"),
++			      isum, j,
++			      GET_DYNAMIC_NAME (filedata, aux.vda_name));
++		    else
++		      printf (_("  %#06lx: Parent %d, name index: %ld\n"),
++			      isum, j, aux.vda_name);
++		  }
++
++		if (j < ent.vd_cnt)
++		  printf (_("  Version def aux past end of section\n"));
++
++		/* PR 17531:
++		   file: id:000001,src:000172+005151,op:splice,rep:2.  */
++		if (ent.vd_next < sizeof (*edef)
++		    && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
++		  {
++		    warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
++		    cnt = section->sh_info;
++		    break;
++		  }
++		if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
++		  break;
++
++		idx += ent.vd_next;
++	      }
++
++	    if (cnt < section->sh_info)
++	      printf (_("  Version definition past end of section\n"));
++
++	    free (edefs);
++	  }
++	  break;
++
++	case SHT_GNU_verneed:
++	  {
++	    Elf_External_Verneed * eneed;
++	    unsigned long idx;
++	    unsigned long cnt;
++	    char * endbuf;
++
++	    found = true;
++
++	    if (filedata->is_separate)
++	      printf (ngettext ("\nIn linked file '%s' the version needs section '%s' contains %u entry:\n",
++				"\nIn linked file '%s' the version needs section '%s' contains %u entries:\n",
++				section->sh_info),
++		      filedata->file_name,
++		      printable_section_name (filedata, section),
++		      section->sh_info);
++	    else
++	      printf (ngettext ("\nVersion needs section '%s' "
++				"contains %u entry:\n",
++				"\nVersion needs section '%s' "
++				"contains %u entries:\n",
++				section->sh_info),
++		      printable_section_name (filedata, section),
++		      section->sh_info);
++
++	    printf (_(" Addr: 0x"));
++	    printf_vma (section->sh_addr);
++	    printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
++		    (unsigned long) section->sh_offset, section->sh_link,
++		    printable_section_name_from_index (filedata, section->sh_link));
++
++	    eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
++                                                       section->sh_offset, 1,
++                                                       section->sh_size,
++                                                       _("Version Needs section"));
++	    if (!eneed)
++	      break;
++	    endbuf = (char *) eneed + section->sh_size;
++
++	    for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
++	      {
++		Elf_External_Verneed * entry;
++		Elf_Internal_Verneed ent;
++		unsigned long isum;
++		int j;
++		char * vstart;
++
++		vstart = ((char *) eneed) + idx;
++		if (vstart + sizeof (*entry) > endbuf)
++		  break;
++
++		entry = (Elf_External_Verneed *) vstart;
++
++		ent.vn_version = BYTE_GET (entry->vn_version);
++		ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
++		ent.vn_file    = BYTE_GET (entry->vn_file);
++		ent.vn_aux     = BYTE_GET (entry->vn_aux);
++		ent.vn_next    = BYTE_GET (entry->vn_next);
++
++		printf (_("  %#06lx: Version: %d"), idx, ent.vn_version);
++
++		if (VALID_DYNAMIC_NAME (filedata, ent.vn_file))
++		  printf (_("  File: %s"),
++			  GET_DYNAMIC_NAME (filedata, ent.vn_file));
++		else
++		  printf (_("  File: %lx"), ent.vn_file);
++
++		printf (_("  Cnt: %d\n"), ent.vn_cnt);
++
++		/* Check for overflow.  */
++		if (ent.vn_aux > (size_t) (endbuf - vstart))
++		  break;
++		vstart += ent.vn_aux;
++
++		for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
++		  {
++		    Elf_External_Vernaux * eaux;
++		    Elf_Internal_Vernaux aux;
++
++		    if (vstart + sizeof (*eaux) > endbuf)
++		      break;
++		    eaux = (Elf_External_Vernaux *) vstart;
++
++		    aux.vna_hash  = BYTE_GET (eaux->vna_hash);
++		    aux.vna_flags = BYTE_GET (eaux->vna_flags);
++		    aux.vna_other = BYTE_GET (eaux->vna_other);
++		    aux.vna_name  = BYTE_GET (eaux->vna_name);
++		    aux.vna_next  = BYTE_GET (eaux->vna_next);
++
++		    if (VALID_DYNAMIC_NAME (filedata, aux.vna_name))
++		      printf (_("  %#06lx:   Name: %s"),
++			      isum, GET_DYNAMIC_NAME (filedata, aux.vna_name));
++		    else
++		      printf (_("  %#06lx:   Name index: %lx"),
++			      isum, aux.vna_name);
++
++		    printf (_("  Flags: %s  Version: %d\n"),
++			    get_ver_flags (aux.vna_flags), aux.vna_other);
++
++		    if (aux.vna_next < sizeof (*eaux)
++			&& !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
++		      {
++			warn (_("Invalid vna_next field of %lx\n"),
++			      aux.vna_next);
++			j = ent.vn_cnt;
++			break;
++		      }
++		    /* Check for overflow.  */
++		    if (aux.vna_next > (size_t) (endbuf - vstart))
++		      break;
++		    isum   += aux.vna_next;
++		    vstart += aux.vna_next;
++		  }
++
++		if (j < ent.vn_cnt)
++		  warn (_("Missing Version Needs auxiliary information\n"));
++
++		if (ent.vn_next < sizeof (*entry)
++		    && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
++		  {
++		    warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
++		    cnt = section->sh_info;
++		    break;
++		  }
++		if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
++		  break;
++		idx += ent.vn_next;
++	      }
++
++	    if (cnt < section->sh_info)
++	      warn (_("Missing Version Needs information\n"));
++
++	    free (eneed);
++	  }
++	  break;
++
++	case SHT_GNU_versym:
++	  {
++	    Elf_Internal_Shdr * link_section;
++	    size_t total;
++	    unsigned int cnt;
++	    unsigned char * edata;
++	    unsigned short * data;
++	    char * strtab;
++	    Elf_Internal_Sym * symbols;
++	    Elf_Internal_Shdr * string_sec;
++	    unsigned long num_syms;
++	    long off;
++
++	    if (section->sh_link >= filedata->file_header.e_shnum)
++	      break;
++
++	    link_section = filedata->section_headers + section->sh_link;
++	    total = section->sh_size / sizeof (Elf_External_Versym);
++
++	    if (link_section->sh_link >= filedata->file_header.e_shnum)
++	      break;
++
++	    found = true;
++
++	    symbols = get_elf_symbols (filedata, link_section, & num_syms);
++	    if (symbols == NULL)
++	      break;
++
++	    string_sec = filedata->section_headers + link_section->sh_link;
++
++	    strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
++                                        string_sec->sh_size,
++                                        _("version string table"));
++	    if (!strtab)
++	      {
++		free (symbols);
++		break;
++	      }
++
++	    if (filedata->is_separate)
++	      printf (ngettext ("\nIn linked file '%s' the version symbols section '%s' contains %lu entry:\n",
++				"\nIn linked file '%s' the version symbols section '%s' contains %lu entries:\n",
++				total),
++		      filedata->file_name,
++		      printable_section_name (filedata, section),
++		      (unsigned long) total);
++	    else
++	      printf (ngettext ("\nVersion symbols section '%s' "
++				"contains %lu entry:\n",
++				"\nVersion symbols section '%s' "
++				"contains %lu entries:\n",
++				total),
++		      printable_section_name (filedata, section),
++		      (unsigned long) total);
++
++	    printf (_(" Addr: 0x"));
++	    printf_vma (section->sh_addr);
++	    printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
++		    (unsigned long) section->sh_offset, section->sh_link,
++		    printable_section_name (filedata, link_section));
++
++	    off = offset_from_vma (filedata,
++				   filedata->version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
++				   total * sizeof (short));
++	    edata = (unsigned char *) get_data (NULL, filedata, off,
++						sizeof (short), total,
++						_("version symbol data"));
++	    if (!edata)
++	      {
++		free (strtab);
++		free (symbols);
++		break;
++	      }
++
++	    data = (short unsigned int *) cmalloc (total, sizeof (short));
++
++	    for (cnt = total; cnt --;)
++	      data[cnt] = byte_get (edata + cnt * sizeof (short),
++				    sizeof (short));
++
++	    free (edata);
++
++	    for (cnt = 0; cnt < total; cnt += 4)
++	      {
++		int j, nn;
++		char *name;
++		char *invalid = _("*invalid*");
++
++		printf ("  %03x:", cnt);
++
++		for (j = 0; (j < 4) && (cnt + j) < total; ++j)
++		  switch (data[cnt + j])
++		    {
++		    case 0:
++		      fputs (_("   0 (*local*)    "), stdout);
++		      break;
++
++		    case 1:
++		      fputs (_("   1 (*global*)   "), stdout);
++		      break;
++
++		    default:
++		      nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
++				   data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
++
++		      /* If this index value is greater than the size of the symbols
++		         array, break to avoid an out-of-bounds read.  */
++		      if ((unsigned long)(cnt + j) >= num_syms)
++		        {
++		          warn (_("invalid index into symbol array\n"));
++		          break;
++			}
++
++		      name = NULL;
++		      if (filedata->version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
++			{
++			  Elf_Internal_Verneed ivn;
++			  unsigned long offset;
++
++			  offset = offset_from_vma
++			    (filedata,
++			     filedata->version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
++			     sizeof (Elf_External_Verneed));
++
++			  do
++			    {
++			      Elf_Internal_Vernaux ivna;
++			      Elf_External_Verneed evn;
++			      Elf_External_Vernaux evna;
++			      unsigned long a_off;
++
++			      if (get_data (&evn, filedata, offset, sizeof (evn), 1,
++					    _("version need")) == NULL)
++				break;
++
++			      ivn.vn_aux  = BYTE_GET (evn.vn_aux);
++			      ivn.vn_next = BYTE_GET (evn.vn_next);
++
++			      a_off = offset + ivn.vn_aux;
++
++			      do
++				{
++				  if (get_data (&evna, filedata, a_off, sizeof (evna),
++						1, _("version need aux (2)")) == NULL)
++				    {
++				      ivna.vna_next  = 0;
++				      ivna.vna_other = 0;
++				    }
++				  else
++				    {
++				      ivna.vna_next  = BYTE_GET (evna.vna_next);
++				      ivna.vna_other = BYTE_GET (evna.vna_other);
++				    }
++
++				  a_off += ivna.vna_next;
++				}
++			      while (ivna.vna_other != data[cnt + j]
++				     && ivna.vna_next != 0);
++
++			      if (ivna.vna_other == data[cnt + j])
++				{
++				  ivna.vna_name = BYTE_GET (evna.vna_name);
++
++				  if (ivna.vna_name >= string_sec->sh_size)
++				    name = invalid;
++				  else
++				    name = strtab + ivna.vna_name;
++				  break;
++				}
++
++			      offset += ivn.vn_next;
++			    }
++			  while (ivn.vn_next);
++			}
++
++		      if (data[cnt + j] != 0x8001
++			  && filedata->version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
++			{
++			  Elf_Internal_Verdef ivd;
++			  Elf_External_Verdef evd;
++			  unsigned long offset;
++
++			  offset = offset_from_vma
++			    (filedata,
++			     filedata->version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
++			     sizeof evd);
++
++			  do
++			    {
++			      if (get_data (&evd, filedata, offset, sizeof (evd), 1,
++					    _("version def")) == NULL)
++				{
++				  ivd.vd_next = 0;
++				  /* PR 17531: file: 046-1082287-0.004.  */
++				  ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
++				  break;
++				}
++			      else
++				{
++				  ivd.vd_next = BYTE_GET (evd.vd_next);
++				  ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
++				}
++
++			      offset += ivd.vd_next;
++			    }
++			  while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
++				 && ivd.vd_next != 0);
++
++			  if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
++			    {
++			      Elf_External_Verdaux evda;
++			      Elf_Internal_Verdaux ivda;
++
++			      ivd.vd_aux = BYTE_GET (evd.vd_aux);
++
++			      if (get_data (&evda, filedata,
++					    offset - ivd.vd_next + ivd.vd_aux,
++					    sizeof (evda), 1,
++					    _("version def aux")) == NULL)
++				break;
++
++			      ivda.vda_name = BYTE_GET (evda.vda_name);
++
++			      if (ivda.vda_name >= string_sec->sh_size)
++				name = invalid;
++			      else if (name != NULL && name != invalid)
++				name = _("*both*");
++			      else
++				name = strtab + ivda.vda_name;
++			    }
++			}
++		      if (name != NULL)
++			nn += printf ("(%s%-*s",
++				      name,
++				      12 - (int) strlen (name),
++				      ")");
++
++		      if (nn < 18)
++			printf ("%*c", 18 - nn, ' ');
++		    }
++
++		putchar ('\n');
++	      }
++
++	    free (data);
++	    free (strtab);
++	    free (symbols);
++	  }
++	  break;
++
++	default:
++	  break;
++	}
++    }
++
++  if (! found)
++    {
++      if (filedata->is_separate)
++	printf (_("\nNo version information found in linked file '%s'.\n"),
++		filedata->file_name);
++      else
++	printf (_("\nNo version information found in this file.\n"));
++    }
++
++  return true;
++}
++
++static const char *
++get_symbol_binding (Filedata * filedata, unsigned int binding)
++{
++  static char buff[64];
++
++  switch (binding)
++    {
++    case STB_LOCAL:	return "LOCAL";
++    case STB_GLOBAL:	return "GLOBAL";
++    case STB_WEAK:	return "WEAK";
++    default:
++      if (binding >= STB_LOPROC && binding <= STB_HIPROC)
++	snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
++		  binding);
++      else if (binding >= STB_LOOS && binding <= STB_HIOS)
++	{
++	  if (binding == STB_GNU_UNIQUE
++	      && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU)
++	    return "UNIQUE";
++	  snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
++	}
++      else
++	snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
++      return buff;
++    }
++}
++
++static const char *
++get_symbol_type (Filedata * filedata, unsigned int type)
++{
++  static char buff[64];
++
++  switch (type)
++    {
++    case STT_NOTYPE:	return "NOTYPE";
++    case STT_OBJECT:	return "OBJECT";
++    case STT_FUNC:	return "FUNC";
++    case STT_SECTION:	return "SECTION";
++    case STT_FILE:	return "FILE";
++    case STT_COMMON:	return "COMMON";
++    case STT_TLS:	return "TLS";
++    case STT_RELC:      return "RELC";
++    case STT_SRELC:     return "SRELC";
++    default:
++      if (type >= STT_LOPROC && type <= STT_HIPROC)
++	{
++	  if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
++	    return "THUMB_FUNC";
++
++	  if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
++	    return "REGISTER";
++
++	  if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
++	    return "PARISC_MILLI";
++
++	  snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
++	}
++      else if (type >= STT_LOOS && type <= STT_HIOS)
++	{
++	  if (filedata->file_header.e_machine == EM_PARISC)
++	    {
++	      if (type == STT_HP_OPAQUE)
++		return "HP_OPAQUE";
++	      if (type == STT_HP_STUB)
++		return "HP_STUB";
++	    }
++
++	  if (type == STT_GNU_IFUNC
++	      && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
++		  || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD))
++	    return "IFUNC";
++
++	  snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
++	}
++      else
++	snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
++      return buff;
++    }
++}
++
++static const char *
++get_symbol_visibility (unsigned int visibility)
++{
++  switch (visibility)
++    {
++    case STV_DEFAULT:	return "DEFAULT";
++    case STV_INTERNAL:	return "INTERNAL";
++    case STV_HIDDEN:	return "HIDDEN";
++    case STV_PROTECTED: return "PROTECTED";
++    default:
++      error (_("Unrecognized visibility value: %u\n"), visibility);
++      return _("<unknown>");
++    }
++}
++
++static const char *
++get_alpha_symbol_other (unsigned int other)
++{
++  switch (other)
++    {
++    case STO_ALPHA_NOPV:       return "NOPV";
++    case STO_ALPHA_STD_GPLOAD: return "STD GPLOAD";
++    default:
++      error (_("Unrecognized alpha specific other value: %u\n"), other);
++      return _("<unknown>");
++    }
++}
++
++static const char *
++get_solaris_symbol_visibility (unsigned int visibility)
++{
++  switch (visibility)
++    {
++    case 4: return "EXPORTED";
++    case 5: return "SINGLETON";
++    case 6: return "ELIMINATE";
++    default: return get_symbol_visibility (visibility);
++    }
++}
++
++static const char *
++get_aarch64_symbol_other (unsigned int other)
++{
++  static char buf[32];
++
++  if (other & STO_AARCH64_VARIANT_PCS)
++    {
++      other &= ~STO_AARCH64_VARIANT_PCS;
++      if (other == 0)
++	return "VARIANT_PCS";
++      snprintf (buf, sizeof buf, "VARIANT_PCS | %x", other);
++      return buf;
++    }
++  return NULL;
++}
++
++static const char *
++get_mips_symbol_other (unsigned int other)
++{
++  switch (other)
++    {
++    case STO_OPTIONAL:      return "OPTIONAL";
++    case STO_MIPS_PLT:      return "MIPS PLT";
++    case STO_MIPS_PIC:      return "MIPS PIC";
++    case STO_MICROMIPS:     return "MICROMIPS";
++    case STO_MICROMIPS | STO_MIPS_PIC:      return "MICROMIPS, MIPS PIC";
++    case STO_MIPS16:        return "MIPS16";
++    default:	            return NULL;
++    }
++}
++
++static const char *
++get_ia64_symbol_other (Filedata * filedata, unsigned int other)
++{
++  if (is_ia64_vms (filedata))
++    {
++      static char res[32];
++
++      res[0] = 0;
++
++      /* Function types is for images and .STB files only.  */
++      switch (filedata->file_header.e_type)
++        {
++        case ET_DYN:
++        case ET_EXEC:
++          switch (VMS_ST_FUNC_TYPE (other))
++            {
++            case VMS_SFT_CODE_ADDR:
++              strcat (res, " CA");
++              break;
++            case VMS_SFT_SYMV_IDX:
++              strcat (res, " VEC");
++              break;
++            case VMS_SFT_FD:
++              strcat (res, " FD");
++              break;
++            case VMS_SFT_RESERVE:
++              strcat (res, " RSV");
++              break;
++            default:
++	      warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
++		    VMS_ST_FUNC_TYPE (other));
++	      strcat (res, " <unknown>");
++	      break;
++            }
++          break;
++        default:
++          break;
++        }
++      switch (VMS_ST_LINKAGE (other))
++        {
++        case VMS_STL_IGNORE:
++          strcat (res, " IGN");
++          break;
++        case VMS_STL_RESERVE:
++          strcat (res, " RSV");
++          break;
++        case VMS_STL_STD:
++          strcat (res, " STD");
++          break;
++        case VMS_STL_LNK:
++          strcat (res, " LNK");
++          break;
++        default:
++	  warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
++		VMS_ST_LINKAGE (other));
++	  strcat (res, " <unknown>");
++	  break;
++        }
++
++      if (res[0] != 0)
++        return res + 1;
++      else
++        return res;
++    }
++  return NULL;
++}
++
++static const char *
++get_ppc64_symbol_other (unsigned int other)
++{
++  if ((other & ~STO_PPC64_LOCAL_MASK) != 0)
++    return NULL;
++
++  other >>= STO_PPC64_LOCAL_BIT;
++  if (other <= 6)
++    {
++      static char buf[64];
++      if (other >= 2)
++	other = ppc64_decode_local_entry (other);
++      snprintf (buf, sizeof buf, _("<localentry>: %d"), other);
++      return buf;
++    }
++  return NULL;
++}
++
++static const char *
++get_symbol_other (Filedata * filedata, unsigned int other)
++{
++  const char * result = NULL;
++  static char buff [64];
++
++  if (other == 0)
++    return "";
++
++  switch (filedata->file_header.e_machine)
++    {
++    case EM_ALPHA:
++      result = get_alpha_symbol_other (other);
++      break;
++    case EM_AARCH64:
++      result = get_aarch64_symbol_other (other);
++      break;
++    case EM_MIPS:
++      result = get_mips_symbol_other (other);
++      break;
++    case EM_IA_64:
++      result = get_ia64_symbol_other (filedata, other);
++      break;
++    case EM_PPC64:
++      result = get_ppc64_symbol_other (other);
++      break;
++    default:
++      result = NULL;
++      break;
++    }
++
++  if (result)
++    return result;
++
++  snprintf (buff, sizeof buff, _("<other>: %x"), other);
++  return buff;
++}
++
++static const char *
++get_symbol_index_type (Filedata * filedata, unsigned int type)
++{
++  static char buff[32];
++
++  switch (type)
++    {
++    case SHN_UNDEF:	return "UND";
++    case SHN_ABS:	return "ABS";
++    case SHN_COMMON:	return "COM";
++    default:
++      if (type == SHN_IA_64_ANSI_COMMON
++	  && filedata->file_header.e_machine == EM_IA_64
++	  && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
++	return "ANSI_COM";
++      else if ((filedata->file_header.e_machine == EM_X86_64
++		|| filedata->file_header.e_machine == EM_L1OM
++		|| filedata->file_header.e_machine == EM_K1OM)
++	       && type == SHN_X86_64_LCOMMON)
++	return "LARGE_COM";
++      else if ((type == SHN_MIPS_SCOMMON
++		&& filedata->file_header.e_machine == EM_MIPS)
++	       || (type == SHN_TIC6X_SCOMMON
++		   && filedata->file_header.e_machine == EM_TI_C6000))
++	return "SCOM";
++      else if (type == SHN_MIPS_SUNDEFINED
++	       && filedata->file_header.e_machine == EM_MIPS)
++	return "SUND";
++      else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
++	sprintf (buff, "PRC[0x%04x]", type & 0xffff);
++      else if (type >= SHN_LOOS && type <= SHN_HIOS)
++	sprintf (buff, "OS [0x%04x]", type & 0xffff);
++      else if (type >= SHN_LORESERVE)
++	sprintf (buff, "RSV[0x%04x]", type & 0xffff);
++      else if (filedata->file_header.e_shnum != 0
++	       && type >= filedata->file_header.e_shnum)
++	sprintf (buff, _("bad section index[%3d]"), type);
++      else
++	sprintf (buff, "%3d", type);
++      break;
++    }
++
++  return buff;
++}
++
++static const char *
++get_symbol_version_string (Filedata *                   filedata,
++			   bool                         is_dynsym,
++			   const char *                 strtab,
++			   unsigned long int            strtab_size,
++			   unsigned int                 si,
++			   Elf_Internal_Sym *           psym,
++			   enum versioned_symbol_info * sym_info,
++			   unsigned short *             vna_other)
++{
++  unsigned char data[2];
++  unsigned short vers_data;
++  unsigned long offset;
++  unsigned short max_vd_ndx;
++
++  if (!is_dynsym
++      || filedata->version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
++    return NULL;
++
++  offset = offset_from_vma (filedata,
++			    filedata->version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
++			    sizeof data + si * sizeof (vers_data));
++
++  if (get_data (&data, filedata, offset + si * sizeof (vers_data),
++		sizeof (data), 1, _("version data")) == NULL)
++    return NULL;
++
++  vers_data = byte_get (data, 2);
++
++  if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data == 0)
++    return NULL;
++
++  *sym_info = (vers_data & VERSYM_HIDDEN) != 0 ? symbol_hidden : symbol_public;
++  max_vd_ndx = 0;
++
++  /* Usually we'd only see verdef for defined symbols, and verneed for
++     undefined symbols.  However, symbols defined by the linker in
++     .dynbss for variables copied from a shared library in order to
++     avoid text relocations are defined yet have verneed.  We could
++     use a heuristic to detect the special case, for example, check
++     for verneed first on symbols defined in SHT_NOBITS sections, but
++     it is simpler and more reliable to just look for both verdef and
++     verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
++
++  if (psym->st_shndx != SHN_UNDEF
++      && vers_data != 0x8001
++      && filedata->version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
++    {
++      Elf_Internal_Verdef ivd;
++      Elf_Internal_Verdaux ivda;
++      Elf_External_Verdaux evda;
++      unsigned long off;
++
++      off = offset_from_vma (filedata,
++			     filedata->version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
++			     sizeof (Elf_External_Verdef));
++
++      do
++	{
++	  Elf_External_Verdef evd;
++
++	  if (get_data (&evd, filedata, off, sizeof (evd), 1,
++			_("version def")) == NULL)
++	    {
++	      ivd.vd_ndx = 0;
++	      ivd.vd_aux = 0;
++	      ivd.vd_next = 0;
++	      ivd.vd_flags = 0;
++	    }
++	  else
++	    {
++	      ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
++	      ivd.vd_aux = BYTE_GET (evd.vd_aux);
++	      ivd.vd_next = BYTE_GET (evd.vd_next);
++	      ivd.vd_flags = BYTE_GET (evd.vd_flags);
++	    }
++
++	  if ((ivd.vd_ndx & VERSYM_VERSION) > max_vd_ndx)
++	    max_vd_ndx = ivd.vd_ndx & VERSYM_VERSION;
++
++	  off += ivd.vd_next;
++	}
++      while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
++
++      if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
++	{
++	  if (ivd.vd_ndx == 1 && ivd.vd_flags == VER_FLG_BASE)
++	    return NULL;
++
++	  off -= ivd.vd_next;
++	  off += ivd.vd_aux;
++
++	  if (get_data (&evda, filedata, off, sizeof (evda), 1,
++			_("version def aux")) != NULL)
++	    {
++	      ivda.vda_name = BYTE_GET (evda.vda_name);
++
++	      if (psym->st_name != ivda.vda_name)
++		return (ivda.vda_name < strtab_size
++			? strtab + ivda.vda_name : _("<corrupt>"));
++	    }
++	}
++    }
++
++  if (filedata->version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
++    {
++      Elf_External_Verneed evn;
++      Elf_Internal_Verneed ivn;
++      Elf_Internal_Vernaux ivna;
++
++      offset = offset_from_vma (filedata,
++				filedata->version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
++				sizeof evn);
++      do
++	{
++	  unsigned long vna_off;
++
++	  if (get_data (&evn, filedata, offset, sizeof (evn), 1,
++			_("version need")) == NULL)
++	    {
++	      ivna.vna_next = 0;
++	      ivna.vna_other = 0;
++	      ivna.vna_name = 0;
++	      break;
++	    }
++
++	  ivn.vn_aux  = BYTE_GET (evn.vn_aux);
++	  ivn.vn_next = BYTE_GET (evn.vn_next);
++
++	  vna_off = offset + ivn.vn_aux;
++
++	  do
++	    {
++	      Elf_External_Vernaux evna;
++
++	      if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
++			    _("version need aux (3)")) == NULL)
++		{
++		  ivna.vna_next = 0;
++		  ivna.vna_other = 0;
++		  ivna.vna_name = 0;
++		}
++	      else
++		{
++		  ivna.vna_other = BYTE_GET (evna.vna_other);
++		  ivna.vna_next  = BYTE_GET (evna.vna_next);
++		  ivna.vna_name  = BYTE_GET (evna.vna_name);
++		}
++
++	      vna_off += ivna.vna_next;
++	    }
++	  while (ivna.vna_other != vers_data && ivna.vna_next != 0);
++
++	  if (ivna.vna_other == vers_data)
++	    break;
++
++	  offset += ivn.vn_next;
++	}
++      while (ivn.vn_next != 0);
++
++      if (ivna.vna_other == vers_data)
++	{
++	  *sym_info = symbol_undefined;
++	  *vna_other = ivna.vna_other;
++	  return (ivna.vna_name < strtab_size
++		  ? strtab + ivna.vna_name : _("<corrupt>"));
++	}
++      else if ((max_vd_ndx || (vers_data & VERSYM_VERSION) != 1)
++	       && (vers_data & VERSYM_VERSION) > max_vd_ndx)
++	return _("<corrupt>");
++    }
++  return NULL;
++}
++
++/* Display a symbol size on stdout.  Format is based on --sym-base setting.  */
++
++static unsigned int
++print_dynamic_symbol_size (bfd_vma vma, int base)
++{
++  switch (base)
++    {
++    case 8:
++      return print_vma (vma, OCTAL_5);
++
++    case 10:
++      return print_vma (vma, UNSIGNED_5);
++
++    case 16:
++      return print_vma (vma, PREFIX_HEX_5);
++
++    case 0:
++    default:
++      return print_vma (vma, DEC_5);
++    }
++}
++
++static void
++print_dynamic_symbol (Filedata *filedata, unsigned long si,
++		      Elf_Internal_Sym *symtab,
++		      Elf_Internal_Shdr *section,
++		      char *strtab, size_t strtab_size)
++{
++  const char *version_string;
++  enum versioned_symbol_info sym_info;
++  unsigned short vna_other;
++  bool is_valid;
++  const char * sstr;
++  Elf_Internal_Sym *psym = symtab + si;
++
++  printf ("%6ld: ", si);
++  print_vma (psym->st_value, LONG_HEX);
++  putchar (' ');
++  print_dynamic_symbol_size (psym->st_size, sym_base);
++  printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
++  printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
++  if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
++    printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
++  else
++    {
++      unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
++
++      printf (" %-7s", get_symbol_visibility (vis));
++#if 0
++      /* Check to see if any other bits in the st_other field are set.
++	 Note - displaying this information disrupts the layout of the
++	 table being generated, but for the moment this case is very rare.  */
++      if (psym->st_other ^ vis)
++	printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
++#endif
++    }
++  printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
++
++  if (ELF_ST_TYPE (psym->st_info) == STT_SECTION
++      && psym->st_shndx < filedata->file_header.e_shnum
++      && psym->st_name == 0)
++    {
++      is_valid = SECTION_NAME_VALID (filedata->section_headers + psym->st_shndx);
++      sstr = is_valid ?
++	SECTION_NAME_PRINT (filedata->section_headers + psym->st_shndx)
++	: _("<corrupt>");
++    }
++  else
++    {
++      is_valid = VALID_SYMBOL_NAME (strtab, strtab_size, psym->st_name);
++      sstr = is_valid  ? strtab + psym->st_name : _("<corrupt>");
++    }
++
++  version_string
++    = get_symbol_version_string (filedata,
++				 (section == NULL
++				  || section->sh_type == SHT_DYNSYM),
++				 strtab, strtab_size, si,
++				 psym, &sym_info, &vna_other);
++
++  int len_avail = 21;
++  if (! do_wide && version_string != NULL)
++    {
++      char buffer[16];
++
++      len_avail -= 1 + strlen (version_string);
++
++      if (sym_info == symbol_undefined)
++	len_avail -= sprintf (buffer," (%d)", vna_other);
++      else if (sym_info != symbol_hidden)
++	len_avail -= 1;
++    }
++
++  print_symbol (len_avail, sstr);
++
++  if (version_string)
++    {
++      if (sym_info == symbol_undefined)
++	printf ("@%s (%d)", version_string, vna_other);
++      else
++	printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
++		version_string);
++    }
++
++#if 1
++    {
++      unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
++
++      /* Check to see if any other bits in the st_other field are set.  */
++      if (psym->st_other ^ vis)
++	printf (" \t[%s]", get_symbol_other (filedata, psym->st_other ^ vis));
++    }
++#endif
++
++    putchar ('\n');
++
++  if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
++      && section != NULL
++      && si >= section->sh_info
++      /* Irix 5 and 6 MIPS binaries are known to ignore this requirement.  */
++      && filedata->file_header.e_machine != EM_MIPS
++      /* Solaris binaries have been found to violate this requirement as
++	 well.  Not sure if this is a bug or an ABI requirement.  */
++      && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
++    warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
++	  si, printable_section_name (filedata, section), section->sh_info);
++}
++
++static const char *
++get_lto_kind (unsigned int kind)
++{
++  switch (kind)
++    {
++    case 0: return "DEF";
++    case 1: return "WEAKDEF";
++    case 2: return "UNDEF";
++    case 3: return "WEAKUNDEF";
++    case 4: return "COMMON";
++    default:
++      break;
++    }
++
++  static char buffer[30];
++  error (_("Unknown LTO symbol definition encountered: %u\n"), kind);
++  sprintf (buffer, "<unknown: %u>", kind);
++  return buffer;
++}
++
++static const char *
++get_lto_visibility (unsigned int visibility)
++{
++  switch (visibility)
++    {
++    case 0: return "DEFAULT";
++    case 1: return "PROTECTED";
++    case 2: return "INTERNAL";
++    case 3: return "HIDDEN";
++    default:
++      break;
++    }
++
++  static char buffer[30];
++  error (_("Unknown LTO symbol visibility encountered: %u\n"), visibility);
++  sprintf (buffer, "<unknown: %u>", visibility);
++  return buffer;
++}
++
++static const char *
++get_lto_sym_type (unsigned int sym_type)
++{
++  switch (sym_type)
++    {
++    case 0: return "UNKNOWN";
++    case 1: return "FUNCTION";
++    case 2: return "VARIABLE";
++    default:
++      break;
++    }
++
++  static char buffer[30];
++  error (_("Unknown LTO symbol type encountered: %u\n"), sym_type);
++  sprintf (buffer, "<unknown: %u>", sym_type);
++  return buffer;
++}
++
++/* Display an LTO format symbol table.
++   FIXME: The format of LTO symbol tables is not formalized.
++   So this code could need changing in the future.  */
++
++static bool
++display_lto_symtab (Filedata *           filedata,
++		    Elf_Internal_Shdr *  section)
++{
++  if (section->sh_size == 0)
++    {
++      if (filedata->is_separate)
++	printf (_("\nThe LTO Symbol table section '%s' in linked file '%s' is empty!\n"),
++		printable_section_name (filedata, section),
++		filedata->file_name);
++      else
++	printf (_("\nLTO Symbol table '%s' is empty!\n"),
++		printable_section_name (filedata, section));
++
++      return true;
++    }
++
++  if (section->sh_size > filedata->file_size)
++    {
++      error (_("Section %s has an invalid sh_size of 0x%lx\n"),
++	     printable_section_name (filedata, section),
++	     (unsigned long) section->sh_size);
++      return false;
++    }
++
++  void * alloced_data = get_data (NULL, filedata, section->sh_offset,
++				  section->sh_size, 1, _("LTO symbols"));
++  if (alloced_data == NULL)
++    return false;
++
++  /* Look for extended data for the symbol table.  */
++  Elf_Internal_Shdr * ext;
++  void * ext_data_orig = NULL;
++  char * ext_data = NULL;
++  char * ext_data_end = NULL;
++  char * ext_name = NULL;
++
++  if (asprintf (& ext_name, ".gnu.lto_.ext_symtab.%s",
++		SECTION_NAME (section) + sizeof (".gnu.lto_.symtab.") - 1) > 0
++      && ext_name != NULL /* Paranoia.  */
++      && (ext = find_section (filedata, ext_name)) != NULL)
++    {
++      if (ext->sh_size < 3)
++	error (_("LTO Symbol extension table '%s' is empty!\n"),
++	       printable_section_name (filedata, ext));
++      else
++	{
++	  ext_data_orig = ext_data = get_data (NULL, filedata, ext->sh_offset,
++					       ext->sh_size, 1,
++					       _("LTO ext symbol data"));
++	  if (ext_data != NULL)
++	    {
++	      ext_data_end = ext_data + ext->sh_size;
++	      if (* ext_data++ != 1)
++		error (_("Unexpected version number in symbol extension table\n"));
++	    }
++	}
++    }
++
++  const unsigned char * data = (const unsigned char *) alloced_data;
++  const unsigned char * end = data + section->sh_size;
++
++  if (filedata->is_separate)
++    printf (_("\nIn linked file '%s': "), filedata->file_name);
++  else
++    printf ("\n");
++
++  if (ext_data_orig != NULL)
++    {
++      if (do_wide)
++	printf (_("LTO Symbol table '%s' and extension table '%s' contain:\n"),
++		printable_section_name (filedata, section),
++		printable_section_name (filedata, ext));
++      else
++	{
++	  printf (_("LTO Symbol table '%s'\n"),
++		  printable_section_name (filedata, section));
++	  printf (_(" and extension table '%s' contain:\n"),
++		  printable_section_name (filedata, ext));
++	}
++    }
++  else
++    printf (_("LTO Symbol table '%s' contains:\n"),
++	    printable_section_name (filedata, section));
++
++  /* FIXME: Add a wide version.  */
++  if (ext_data_orig != NULL)
++    printf (_("  Comdat_Key       Kind  Visibility     Size      Slot      Type  Section Name\n"));
++  else
++    printf (_("  Comdat_Key       Kind  Visibility     Size      Slot Name\n"));
++
++  /* FIXME: We do not handle style prefixes.  */
++
++  while (data < end)
++    {
++      const unsigned char * sym_name = data;
++      data += strnlen ((const char *) sym_name, end - data) + 1;
++      if (data >= end)
++	goto fail;
++
++      const unsigned char * comdat_key = data;
++      data += strnlen ((const char *) comdat_key, end - data) + 1;
++      if (data >= end)
++	goto fail;
++
++      if (data + 2 + 8 + 4 > end)
++	goto fail;
++
++      unsigned int kind = *data++;
++      unsigned int visibility = *data++;
++
++      elf_vma size = byte_get (data, 8);
++      data += 8;
++
++      elf_vma slot = byte_get (data, 4);
++      data += 4;
++
++      if (ext_data != NULL)
++	{
++	  if (ext_data < (ext_data_end - 1))
++	    {
++	      unsigned int sym_type = * ext_data ++;
++	      unsigned int sec_kind = * ext_data ++;
++
++	      printf ("  %10s %10s %11s %08lx  %08lx %9s %08lx _",
++		      * comdat_key == 0 ? "-" : (char *) comdat_key,
++		      get_lto_kind (kind),
++		      get_lto_visibility (visibility),
++		      (long) size,
++		      (long) slot,
++		      get_lto_sym_type (sym_type),
++		      (long) sec_kind);
++	      print_symbol (6, (const char *) sym_name);
++	    }
++	  else
++	    {
++	      error (_("Ran out of LTO symbol extension data\n"));
++	      ext_data = NULL;
++	      /* FIXME: return FAIL result ?  */
++	    }
++	}
++      else
++	{
++	  printf ("  %10s %10s %11s %08lx  %08lx _",
++		  * comdat_key == 0 ? "-" : (char *) comdat_key,
++		  get_lto_kind (kind),
++		  get_lto_visibility (visibility),
++		  (long) size,
++		  (long) slot);
++	  print_symbol (21, (const char *) sym_name);
++	}
++      putchar ('\n');
++    }
++
++  if (ext_data != NULL && ext_data < ext_data_end)
++    {
++      error (_("Data remains in the LTO symbol extension table\n"));
++      goto fail;
++    }
++
++  free (alloced_data);
++  free (ext_data_orig);
++  free (ext_name);
++  return true;
++
++ fail:
++  error (_("Buffer overrun encountered whilst decoding LTO symbol table\n"));
++  free (alloced_data);
++  free (ext_data_orig);
++  free (ext_name);
++  return false;
++}
++
++/* Display LTO symbol tables.  */
++
++static bool
++process_lto_symbol_tables (Filedata * filedata)
++{
++  Elf_Internal_Shdr * section;
++  unsigned int i;
++  bool res = true;
++
++  if (!do_lto_syms)
++    return true;
++
++  if (filedata->section_headers == NULL)
++    return true;
++
++  for (i = 0, section = filedata->section_headers;
++       i < filedata->file_header.e_shnum;
++       i++, section++)
++    if (SECTION_NAME_VALID (section)
++	&& startswith (SECTION_NAME (section), ".gnu.lto_.symtab."))
++      res &= display_lto_symtab (filedata, section);
++
++  return res;
++}
++
++/* Dump the symbol table.  */
++
++static bool
++process_symbol_table (Filedata * filedata)
++{
++  Elf_Internal_Shdr * section;
++
++  if (!do_syms && !do_dyn_syms && !do_histogram)
++    return true;
++
++  if ((filedata->dynamic_info[DT_HASH] || filedata->dynamic_info_DT_GNU_HASH)
++      && do_syms
++      && do_using_dynamic
++      && filedata->dynamic_strings != NULL
++      && filedata->dynamic_symbols != NULL)
++    {
++      unsigned long si;
++
++      if (filedata->is_separate)
++	{
++	  printf (ngettext ("\nIn linked file '%s' the dynamic symbol table contains %lu entry:\n",
++			    "\nIn linked file '%s' the dynamic symbol table contains %lu entries:\n",
++			    filedata->num_dynamic_syms),
++		  filedata->file_name,
++		  filedata->num_dynamic_syms);
++	}
++      else
++	{
++	  printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
++			    "\nSymbol table for image contains %lu entries:\n",
++			    filedata->num_dynamic_syms),
++		  filedata->num_dynamic_syms);
++	}
++      if (is_32bit_elf)
++	printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
++      else
++	printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
++
++      for (si = 0; si < filedata->num_dynamic_syms; si++)
++	print_dynamic_symbol (filedata, si, filedata->dynamic_symbols, NULL,
++			      filedata->dynamic_strings,
++			      filedata->dynamic_strings_length);
++    }
++  else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
++	   && filedata->section_headers != NULL)
++    {
++      unsigned int i;
++
++      for (i = 0, section = filedata->section_headers;
++	   i < filedata->file_header.e_shnum;
++	   i++, section++)
++	{
++	  char * strtab = NULL;
++	  unsigned long int strtab_size = 0;
++	  Elf_Internal_Sym * symtab;
++	  unsigned long si, num_syms;
++
++	  if ((section->sh_type != SHT_SYMTAB
++	       && section->sh_type != SHT_DYNSYM)
++	      || (!do_syms
++		  && section->sh_type == SHT_SYMTAB))
++	    continue;
++
++	  if (section->sh_entsize == 0)
++	    {
++	      printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
++		      printable_section_name (filedata, section));
++	      continue;
++	    }
++
++	  num_syms = section->sh_size / section->sh_entsize;
++
++	  if (filedata->is_separate)
++	    printf (ngettext ("\nIn linked file '%s' symbol section '%s' contains %lu entry:\n",
++			      "\nIn linked file '%s' symbol section '%s' contains %lu entries:\n",
++			      num_syms),
++		    filedata->file_name,
++		    printable_section_name (filedata, section),
++		    num_syms);
++	  else
++	    printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
++			      "\nSymbol table '%s' contains %lu entries:\n",
++			      num_syms),
++		    printable_section_name (filedata, section),
++		    num_syms);
++
++	  if (is_32bit_elf)
++	    printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
++	  else
++	    printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
++
++	  symtab = get_elf_symbols (filedata, section, & num_syms);
++	  if (symtab == NULL)
++	    continue;
++
++	  if (section->sh_link == filedata->file_header.e_shstrndx)
++	    {
++	      strtab = filedata->string_table;
++	      strtab_size = filedata->string_table_length;
++	    }
++	  else if (section->sh_link < filedata->file_header.e_shnum)
++	    {
++	      Elf_Internal_Shdr * string_sec;
++
++	      string_sec = filedata->section_headers + section->sh_link;
++
++	      strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
++                                          1, string_sec->sh_size,
++                                          _("string table"));
++	      strtab_size = strtab != NULL ? string_sec->sh_size : 0;
++	    }
++
++	  for (si = 0; si < num_syms; si++)
++	    print_dynamic_symbol (filedata, si, symtab, section,
++				  strtab, strtab_size);
++
++	  free (symtab);
++	  if (strtab != filedata->string_table)
++	    free (strtab);
++	}
++    }
++  else if (do_syms)
++    printf
++      (_("\nDynamic symbol information is not available for displaying symbols.\n"));
++
++  if (do_histogram && filedata->buckets != NULL)
++    {
++      unsigned long * lengths;
++      unsigned long * counts;
++      unsigned long hn;
++      bfd_vma si;
++      unsigned long maxlength = 0;
++      unsigned long nzero_counts = 0;
++      unsigned long nsyms = 0;
++      char *visited;
++
++      printf (ngettext ("\nHistogram for bucket list length "
++			"(total of %lu bucket):\n",
++			"\nHistogram for bucket list length "
++			"(total of %lu buckets):\n",
++			(unsigned long) filedata->nbuckets),
++	      (unsigned long) filedata->nbuckets);
++
++      lengths = (unsigned long *) calloc (filedata->nbuckets,
++					  sizeof (*lengths));
++      if (lengths == NULL)
++	{
++	  error (_("Out of memory allocating space for histogram buckets\n"));
++	  goto err_out;
++	}
++      visited = xcmalloc (filedata->nchains, 1);
++      memset (visited, 0, filedata->nchains);
++
++      printf (_(" Length  Number     %% of total  Coverage\n"));
++      for (hn = 0; hn < filedata->nbuckets; ++hn)
++	{
++	  for (si = filedata->buckets[hn]; si > 0; si = filedata->chains[si])
++	    {
++	      ++nsyms;
++	      if (maxlength < ++lengths[hn])
++		++maxlength;
++	      if (si >= filedata->nchains || visited[si])
++		{
++		  error (_("histogram chain is corrupt\n"));
++		  break;
++		}
++	      visited[si] = 1;
++	    }
++	}
++      free (visited);
++
++      counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
++      if (counts == NULL)
++	{
++	  free (lengths);
++	  error (_("Out of memory allocating space for histogram counts\n"));
++	  goto err_out;
++	}
++
++      for (hn = 0; hn < filedata->nbuckets; ++hn)
++	++counts[lengths[hn]];
++
++      if (filedata->nbuckets > 0)
++	{
++	  unsigned long i;
++	  printf ("      0  %-10lu (%5.1f%%)\n",
++		  counts[0], (counts[0] * 100.0) / filedata->nbuckets);
++	  for (i = 1; i <= maxlength; ++i)
++	    {
++	      nzero_counts += counts[i] * i;
++	      printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
++		      i, counts[i], (counts[i] * 100.0) / filedata->nbuckets,
++		      (nzero_counts * 100.0) / nsyms);
++	    }
++	}
++
++      free (counts);
++      free (lengths);
++    }
++
++  free (filedata->buckets);
++  filedata->buckets = NULL;
++  filedata->nbuckets = 0;
++  free (filedata->chains);
++  filedata->chains = NULL;
++
++  if (do_histogram && filedata->gnubuckets != NULL)
++    {
++      unsigned long * lengths;
++      unsigned long * counts;
++      unsigned long hn;
++      unsigned long maxlength = 0;
++      unsigned long nzero_counts = 0;
++      unsigned long nsyms = 0;
++
++      printf (ngettext ("\nHistogram for `%s' bucket list length "
++			"(total of %lu bucket):\n",
++			"\nHistogram for `%s' bucket list length "
++			"(total of %lu buckets):\n",
++			(unsigned long) filedata->ngnubuckets),
++	      GNU_HASH_SECTION_NAME (filedata),
++	      (unsigned long) filedata->ngnubuckets);
++
++      lengths = (unsigned long *) calloc (filedata->ngnubuckets,
++					  sizeof (*lengths));
++      if (lengths == NULL)
++	{
++	  error (_("Out of memory allocating space for gnu histogram buckets\n"));
++	  goto err_out;
++	}
++
++      printf (_(" Length  Number     %% of total  Coverage\n"));
++
++      for (hn = 0; hn < filedata->ngnubuckets; ++hn)
++	if (filedata->gnubuckets[hn] != 0)
++	  {
++	    bfd_vma off, length = 1;
++
++	    for (off = filedata->gnubuckets[hn] - filedata->gnusymidx;
++		 /* PR 17531 file: 010-77222-0.004.  */
++		 off < filedata->ngnuchains
++		   && (filedata->gnuchains[off] & 1) == 0;
++		 ++off)
++	      ++length;
++	    lengths[hn] = length;
++	    if (length > maxlength)
++	      maxlength = length;
++	    nsyms += length;
++	  }
++
++      counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
++      if (counts == NULL)
++	{
++	  free (lengths);
++	  error (_("Out of memory allocating space for gnu histogram counts\n"));
++	  goto err_out;
++	}
++
++      for (hn = 0; hn < filedata->ngnubuckets; ++hn)
++	++counts[lengths[hn]];
++
++      if (filedata->ngnubuckets > 0)
++	{
++	  unsigned long j;
++	  printf ("      0  %-10lu (%5.1f%%)\n",
++		  counts[0], (counts[0] * 100.0) / filedata->ngnubuckets);
++	  for (j = 1; j <= maxlength; ++j)
++	    {
++	      nzero_counts += counts[j] * j;
++	      printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
++		      j, counts[j], (counts[j] * 100.0) / filedata->ngnubuckets,
++		      (nzero_counts * 100.0) / nsyms);
++	    }
++	}
++
++      free (counts);
++      free (lengths);
++    }
++  free (filedata->gnubuckets);
++  filedata->gnubuckets = NULL;
++  filedata->ngnubuckets = 0;
++  free (filedata->gnuchains);
++  filedata->gnuchains = NULL;
++  filedata->ngnuchains = 0;
++  free (filedata->mipsxlat);
++  filedata->mipsxlat = NULL;
++  return true;
++
++ err_out:
++  free (filedata->gnubuckets);
++  filedata->gnubuckets = NULL;
++  filedata->ngnubuckets = 0;
++  free (filedata->gnuchains);
++  filedata->gnuchains = NULL;
++  filedata->ngnuchains = 0;
++  free (filedata->mipsxlat);
++  filedata->mipsxlat = NULL;
++  free (filedata->buckets);
++  filedata->buckets = NULL;
++  filedata->nbuckets = 0;
++  free (filedata->chains);
++  filedata->chains = NULL;
++  return false;
++}
++
++static bool
++process_syminfo (Filedata * filedata)
++{
++  unsigned int i;
++
++  if (filedata->dynamic_syminfo == NULL
++      || !do_dynamic)
++    /* No syminfo, this is ok.  */
++    return true;
++
++  /* There better should be a dynamic symbol section.  */
++  if (filedata->dynamic_symbols == NULL || filedata->dynamic_strings == NULL)
++    return false;
++
++  if (filedata->is_separate)
++    printf (ngettext ("\nIn linked file '%s: the dynamic info segment at offset 0x%lx contains %d entry:\n",
++		      "\nIn linked file '%s: the dynamic info segment at offset 0x%lx contains %d entries:\n",
++		      filedata->dynamic_syminfo_nent),
++	    filedata->file_name,
++	    filedata->dynamic_syminfo_offset,
++	    filedata->dynamic_syminfo_nent);
++  else
++    printf (ngettext ("\nDynamic info segment at offset 0x%lx "
++		      "contains %d entry:\n",
++		      "\nDynamic info segment at offset 0x%lx "
++		      "contains %d entries:\n",
++		      filedata->dynamic_syminfo_nent),
++	    filedata->dynamic_syminfo_offset,
++	    filedata->dynamic_syminfo_nent);
++
++  printf (_(" Num: Name                           BoundTo     Flags\n"));
++  for (i = 0; i < filedata->dynamic_syminfo_nent; ++i)
++    {
++      unsigned short int flags = filedata->dynamic_syminfo[i].si_flags;
++
++      printf ("%4d: ", i);
++      if (i >= filedata->num_dynamic_syms)
++	printf (_("<corrupt index>"));
++      else if (VALID_DYNAMIC_NAME (filedata, filedata->dynamic_symbols[i].st_name))
++	print_symbol (30, GET_DYNAMIC_NAME (filedata,
++					    filedata->dynamic_symbols[i].st_name));
++      else
++	printf (_("<corrupt: %19ld>"), filedata->dynamic_symbols[i].st_name);
++      putchar (' ');
++
++      switch (filedata->dynamic_syminfo[i].si_boundto)
++	{
++	case SYMINFO_BT_SELF:
++	  fputs ("SELF       ", stdout);
++	  break;
++	case SYMINFO_BT_PARENT:
++	  fputs ("PARENT     ", stdout);
++	  break;
++	default:
++	  if (filedata->dynamic_syminfo[i].si_boundto > 0
++	      && filedata->dynamic_syminfo[i].si_boundto < filedata->dynamic_nent
++	      && VALID_DYNAMIC_NAME (filedata,
++				     filedata->dynamic_section[filedata->dynamic_syminfo[i].si_boundto].d_un.d_val))
++	    {
++	      print_symbol (10, GET_DYNAMIC_NAME (filedata,
++						  filedata->dynamic_section[filedata->dynamic_syminfo[i].si_boundto].d_un.d_val));
++	      putchar (' ' );
++	    }
++	  else
++	    printf ("%-10d ", filedata->dynamic_syminfo[i].si_boundto);
++	  break;
++	}
++
++      if (flags & SYMINFO_FLG_DIRECT)
++	printf (" DIRECT");
++      if (flags & SYMINFO_FLG_PASSTHRU)
++	printf (" PASSTHRU");
++      if (flags & SYMINFO_FLG_COPY)
++	printf (" COPY");
++      if (flags & SYMINFO_FLG_LAZYLOAD)
++	printf (" LAZYLOAD");
++
++      puts ("");
++    }
++
++  return true;
++}
++
++/* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
++   is contained by the region START .. END.  The types of ADDR, START
++   and END should all be the same.  Note both ADDR + NELEM and END
++   point to just beyond the end of the regions that are being tested.  */
++#define IN_RANGE(START,END,ADDR,NELEM)		\
++  (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
++
++/* Check to see if the given reloc needs to be handled in a target specific
++   manner.  If so then process the reloc and return TRUE otherwise return
++   FALSE.
++
++   If called with reloc == NULL, then this is a signal that reloc processing
++   for the current section has finished, and any saved state should be
++   discarded.  */
++
++static bool
++target_specific_reloc_handling (Filedata *           filedata,
++				Elf_Internal_Rela *  reloc,
++				unsigned char *      start,
++				unsigned char *      end,
++				Elf_Internal_Sym *   symtab,
++				unsigned long        num_syms)
++{
++  unsigned int reloc_type = 0;
++  unsigned long sym_index = 0;
++
++  if (reloc)
++    {
++      reloc_type = get_reloc_type (filedata, reloc->r_info);
++      sym_index = get_reloc_symindex (reloc->r_info);
++    }
++
++  switch (filedata->file_header.e_machine)
++    {
++    case EM_MSP430:
++    case EM_MSP430_OLD:
++      {
++	static Elf_Internal_Sym * saved_sym = NULL;
++
++	if (reloc == NULL)
++	  {
++	    saved_sym = NULL;
++	    return true;
++	  }
++
++	switch (reloc_type)
++	  {
++	  case 10: /* R_MSP430_SYM_DIFF */
++	  case 12: /* R_MSP430_GNU_SUB_ULEB128 */
++	    if (uses_msp430x_relocs (filedata))
++	      break;
++	    /* Fall through.  */
++	  case 21: /* R_MSP430X_SYM_DIFF */
++	  case 23: /* R_MSP430X_GNU_SUB_ULEB128 */
++	    /* PR 21139.  */
++	    if (sym_index >= num_syms)
++	      error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
++		     sym_index);
++	    else
++	      saved_sym = symtab + sym_index;
++	    return true;
++
++	  case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
++	  case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
++	    goto handle_sym_diff;
++
++	  case 5: /* R_MSP430_16_BYTE */
++	  case 9: /* R_MSP430_8 */
++	  case 11: /* R_MSP430_GNU_SET_ULEB128 */
++	    if (uses_msp430x_relocs (filedata))
++	      break;
++	    goto handle_sym_diff;
++
++	  case 2: /* R_MSP430_ABS16 */
++	  case 15: /* R_MSP430X_ABS16 */
++	  case 22: /* R_MSP430X_GNU_SET_ULEB128 */
++	    if (! uses_msp430x_relocs (filedata))
++	      break;
++	    goto handle_sym_diff;
++
++	  handle_sym_diff:
++	    if (saved_sym != NULL)
++	      {
++		bfd_vma value;
++		unsigned int reloc_size = 0;
++		int leb_ret = 0;
++		switch (reloc_type)
++		  {
++		  case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
++		    reloc_size = 4;
++		    break;
++		  case 11: /* R_MSP430_GNU_SET_ULEB128 */
++		  case 22: /* R_MSP430X_GNU_SET_ULEB128 */
++		    if (reloc->r_offset < (size_t) (end - start))
++		      read_leb128 (start + reloc->r_offset, end, false,
++				   &reloc_size, &leb_ret);
++		    break;
++		  default:
++		    reloc_size = 2;
++		    break;
++		  }
++
++		if (leb_ret != 0 || reloc_size == 0 || reloc_size > 8)
++		  error (_("MSP430 ULEB128 field at 0x%lx contains invalid "
++			   "ULEB128 value\n"),
++			 (long) reloc->r_offset);
++		else if (sym_index >= num_syms)
++		  error (_("MSP430 reloc contains invalid symbol index %lu\n"),
++			 sym_index);
++		else
++		  {
++		    value = reloc->r_addend + (symtab[sym_index].st_value
++					       - saved_sym->st_value);
++
++		    if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
++		      byte_put (start + reloc->r_offset, value, reloc_size);
++		    else
++		      /* PR 21137 */
++		      error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
++			     (long) reloc->r_offset);
++		  }
++
++		saved_sym = NULL;
++		return true;
++	      }
++	    break;
++
++	  default:
++	    if (saved_sym != NULL)
++	      error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
++	    break;
++	  }
++	break;
++      }
++
++    case EM_MN10300:
++    case EM_CYGNUS_MN10300:
++      {
++	static Elf_Internal_Sym * saved_sym = NULL;
++
++	if (reloc == NULL)
++	  {
++	    saved_sym = NULL;
++	    return true;
++	  }
++
++	switch (reloc_type)
++	  {
++	  case 34: /* R_MN10300_ALIGN */
++	    return true;
++	  case 33: /* R_MN10300_SYM_DIFF */
++	    if (sym_index >= num_syms)
++	      error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
++		     sym_index);
++	    else
++	      saved_sym = symtab + sym_index;
++	    return true;
++
++	  case 1: /* R_MN10300_32 */
++	  case 2: /* R_MN10300_16 */
++	    if (saved_sym != NULL)
++	      {
++		int reloc_size = reloc_type == 1 ? 4 : 2;
++		bfd_vma value;
++
++		if (sym_index >= num_syms)
++		  error (_("MN10300 reloc contains invalid symbol index %lu\n"),
++			 sym_index);
++		else
++		  {
++		    value = reloc->r_addend + (symtab[sym_index].st_value
++					       - saved_sym->st_value);
++
++		    if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
++		      byte_put (start + reloc->r_offset, value, reloc_size);
++		    else
++		      error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
++			     (long) reloc->r_offset);
++		  }
++
++		saved_sym = NULL;
++		return true;
++	      }
++	    break;
++	  default:
++	    if (saved_sym != NULL)
++	      error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
++	    break;
++	  }
++	break;
++      }
++
++    case EM_RL78:
++      {
++	static bfd_vma saved_sym1 = 0;
++	static bfd_vma saved_sym2 = 0;
++	static bfd_vma value;
++
++	if (reloc == NULL)
++	  {
++	    saved_sym1 = saved_sym2 = 0;
++	    return true;
++	  }
++
++	switch (reloc_type)
++	  {
++	  case 0x80: /* R_RL78_SYM.  */
++	    saved_sym1 = saved_sym2;
++	    if (sym_index >= num_syms)
++	      error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
++		     sym_index);
++	    else
++	      {
++		saved_sym2 = symtab[sym_index].st_value;
++		saved_sym2 += reloc->r_addend;
++	      }
++	    return true;
++
++	  case 0x83: /* R_RL78_OPsub.  */
++	    value = saved_sym1 - saved_sym2;
++	    saved_sym2 = saved_sym1 = 0;
++	    return true;
++	    break;
++
++	  case 0x41: /* R_RL78_ABS32.  */
++	    if (IN_RANGE (start, end, start + reloc->r_offset, 4))
++	      byte_put (start + reloc->r_offset, value, 4);
++	    else
++	      error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
++		     (long) reloc->r_offset);
++	    value = 0;
++	    return true;
++
++	  case 0x43: /* R_RL78_ABS16.  */
++	    if (IN_RANGE (start, end, start + reloc->r_offset, 2))
++	      byte_put (start + reloc->r_offset, value, 2);
++	    else
++	      error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
++		     (long) reloc->r_offset);
++	    value = 0;
++	    return true;
++
++	  default:
++	    break;
++	  }
++	break;
++      }
++    }
++
++  return false;
++}
++
++/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
++   DWARF debug sections.  This is a target specific test.  Note - we do not
++   go through the whole including-target-headers-multiple-times route, (as
++   we have already done with <elf/h8.h>) because this would become very
++   messy and even then this function would have to contain target specific
++   information (the names of the relocs instead of their numeric values).
++   FIXME: This is not the correct way to solve this problem.  The proper way
++   is to have target specific reloc sizing and typing functions created by
++   the reloc-macros.h header, in the same way that it already creates the
++   reloc naming functions.  */
++
++static bool
++is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
++{
++  /* Please keep this table alpha-sorted for ease of visual lookup.  */
++  switch (filedata->file_header.e_machine)
++    {
++    case EM_386:
++    case EM_IAMCU:
++      return reloc_type == 1; /* R_386_32.  */
++    case EM_68K:
++      return reloc_type == 1; /* R_68K_32.  */
++    case EM_860:
++      return reloc_type == 1; /* R_860_32.  */
++    case EM_960:
++      return reloc_type == 2; /* R_960_32.  */
++    case EM_AARCH64:
++      return (reloc_type == 258
++	      || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
++    case EM_BPF:
++      return reloc_type == 11; /* R_BPF_DATA_32 */
++    case EM_ADAPTEVA_EPIPHANY:
++      return reloc_type == 3;
++    case EM_ALPHA:
++      return reloc_type == 1; /* R_ALPHA_REFLONG.  */
++    case EM_ARC:
++      return reloc_type == 1; /* R_ARC_32.  */
++    case EM_ARC_COMPACT:
++    case EM_ARC_COMPACT2:
++      return reloc_type == 4; /* R_ARC_32.  */
++    case EM_ARM:
++      return reloc_type == 2; /* R_ARM_ABS32 */
++    case EM_AVR_OLD:
++    case EM_AVR:
++      return reloc_type == 1;
++    case EM_BLACKFIN:
++      return reloc_type == 0x12; /* R_byte4_data.  */
++    case EM_CRIS:
++      return reloc_type == 3; /* R_CRIS_32.  */
++    case EM_CR16:
++      return reloc_type == 3; /* R_CR16_NUM32.  */
++    case EM_CRX:
++      return reloc_type == 15; /* R_CRX_NUM32.  */
++    case EM_CSKY:
++      return reloc_type == 1; /* R_CKCORE_ADDR32.  */
++    case EM_CYGNUS_FRV:
++      return reloc_type == 1;
++    case EM_CYGNUS_D10V:
++    case EM_D10V:
++      return reloc_type == 6; /* R_D10V_32.  */
++    case EM_CYGNUS_D30V:
++    case EM_D30V:
++      return reloc_type == 12; /* R_D30V_32_NORMAL.  */
++    case EM_DLX:
++      return reloc_type == 3; /* R_DLX_RELOC_32.  */
++    case EM_CYGNUS_FR30:
++    case EM_FR30:
++      return reloc_type == 3; /* R_FR30_32.  */
++    case EM_FT32:
++      return reloc_type == 1; /* R_FT32_32.  */
++    case EM_H8S:
++    case EM_H8_300:
++    case EM_H8_300H:
++      return reloc_type == 1; /* R_H8_DIR32.  */
++    case EM_IA_64:
++      return (reloc_type == 0x64    /* R_IA64_SECREL32MSB.  */
++	      || reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
++	      || reloc_type == 0x24 /* R_IA64_DIR32MSB.  */
++	      || reloc_type == 0x25 /* R_IA64_DIR32LSB.  */);
++    case EM_IP2K_OLD:
++    case EM_IP2K:
++      return reloc_type == 2; /* R_IP2K_32.  */
++    case EM_IQ2000:
++      return reloc_type == 2; /* R_IQ2000_32.  */
++    case EM_LATTICEMICO32:
++      return reloc_type == 3; /* R_LM32_32.  */
++    case EM_M32C_OLD:
++    case EM_M32C:
++      return reloc_type == 3; /* R_M32C_32.  */
++    case EM_M32R:
++      return reloc_type == 34; /* R_M32R_32_RELA.  */
++    case EM_68HC11:
++    case EM_68HC12:
++      return reloc_type == 6; /* R_M68HC11_32.  */
++    case EM_S12Z:
++      return reloc_type == 7 || /* R_S12Z_EXT32 */
++	reloc_type == 6;        /* R_S12Z_CW32.  */
++    case EM_MCORE:
++      return reloc_type == 1; /* R_MCORE_ADDR32.  */
++    case EM_CYGNUS_MEP:
++      return reloc_type == 4; /* R_MEP_32.  */
++    case EM_METAG:
++      return reloc_type == 2; /* R_METAG_ADDR32.  */
++    case EM_MICROBLAZE:
++      return reloc_type == 1; /* R_MICROBLAZE_32.  */
++    case EM_MIPS:
++      return reloc_type == 2; /* R_MIPS_32.  */
++    case EM_MMIX:
++      return reloc_type == 4; /* R_MMIX_32.  */
++    case EM_CYGNUS_MN10200:
++    case EM_MN10200:
++      return reloc_type == 1; /* R_MN10200_32.  */
++    case EM_CYGNUS_MN10300:
++    case EM_MN10300:
++      return reloc_type == 1; /* R_MN10300_32.  */
++    case EM_MOXIE:
++      return reloc_type == 1; /* R_MOXIE_32.  */
++    case EM_MSP430_OLD:
++    case EM_MSP430:
++      return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
++    case EM_MT:
++      return reloc_type == 2; /* R_MT_32.  */
++    case EM_NDS32:
++      return reloc_type == 20; /* R_NDS32_RELA.  */
++    case EM_ALTERA_NIOS2:
++      return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
++    case EM_NIOS32:
++      return reloc_type == 1; /* R_NIOS_32.  */
++    case EM_OR1K:
++      return reloc_type == 1; /* R_OR1K_32.  */
++    case EM_PARISC:
++      return (reloc_type == 1 /* R_PARISC_DIR32.  */
++	      || reloc_type == 2 /* R_PARISC_DIR21L.  */
++	      || reloc_type == 41); /* R_PARISC_SECREL32.  */
++    case EM_PJ:
++    case EM_PJ_OLD:
++      return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
++    case EM_PPC64:
++      return reloc_type == 1; /* R_PPC64_ADDR32.  */
++    case EM_PPC:
++      return reloc_type == 1; /* R_PPC_ADDR32.  */
++    case EM_TI_PRU:
++      return reloc_type == 11; /* R_PRU_BFD_RELOC_32.  */
++    case EM_RISCV:
++      return reloc_type == 1; /* R_RISCV_32.  */
++    case EM_RL78:
++      return reloc_type == 1; /* R_RL78_DIR32.  */
++    case EM_RX:
++      return reloc_type == 1; /* R_RX_DIR32.  */
++    case EM_S370:
++      return reloc_type == 1; /* R_I370_ADDR31.  */
++    case EM_S390_OLD:
++    case EM_S390:
++      return reloc_type == 4; /* R_S390_32.  */
++    case EM_SCORE:
++      return reloc_type == 8; /* R_SCORE_ABS32.  */
++    case EM_SH:
++      return reloc_type == 1; /* R_SH_DIR32.  */
++    case EM_SPARC32PLUS:
++    case EM_SPARCV9:
++    case EM_SPARC:
++      return reloc_type == 3 /* R_SPARC_32.  */
++	|| reloc_type == 23; /* R_SPARC_UA32.  */
++    case EM_SPU:
++      return reloc_type == 6; /* R_SPU_ADDR32 */
++    case EM_TI_C6000:
++      return reloc_type == 1; /* R_C6000_ABS32.  */
++    case EM_TILEGX:
++      return reloc_type == 2; /* R_TILEGX_32.  */
++    case EM_TILEPRO:
++      return reloc_type == 1; /* R_TILEPRO_32.  */
++    case EM_CYGNUS_V850:
++    case EM_V850:
++      return reloc_type == 6; /* R_V850_ABS32.  */
++    case EM_V800:
++      return reloc_type == 0x33; /* R_V810_WORD.  */
++    case EM_VAX:
++      return reloc_type == 1; /* R_VAX_32.  */
++    case EM_VISIUM:
++      return reloc_type == 3;  /* R_VISIUM_32. */
++    case EM_WEBASSEMBLY:
++      return reloc_type == 1;  /* R_WASM32_32.  */
++    case EM_X86_64:
++    case EM_L1OM:
++    case EM_K1OM:
++      return reloc_type == 10; /* R_X86_64_32.  */
++    case EM_XC16X:
++    case EM_C166:
++      return reloc_type == 3; /* R_XC16C_ABS_32.  */
++    case EM_XGATE:
++      return reloc_type == 4; /* R_XGATE_32.  */
++    case EM_XSTORMY16:
++      return reloc_type == 1; /* R_XSTROMY16_32.  */
++    case EM_XTENSA_OLD:
++    case EM_XTENSA:
++      return reloc_type == 1; /* R_XTENSA_32.  */
++    case EM_Z80:
++      return reloc_type == 6; /* R_Z80_32.  */
++    default:
++      {
++	static unsigned int prev_warn = 0;
++
++	/* Avoid repeating the same warning multiple times.  */
++	if (prev_warn != filedata->file_header.e_machine)
++	  error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
++		 filedata->file_header.e_machine);
++	prev_warn = filedata->file_header.e_machine;
++	return false;
++      }
++    }
++}
++
++/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
++   a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
++
++static bool
++is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
++{
++  switch (filedata->file_header.e_machine)
++  /* Please keep this table alpha-sorted for ease of visual lookup.  */
++    {
++    case EM_386:
++    case EM_IAMCU:
++      return reloc_type == 2;  /* R_386_PC32.  */
++    case EM_68K:
++      return reloc_type == 4;  /* R_68K_PC32.  */
++    case EM_AARCH64:
++      return reloc_type == 261; /* R_AARCH64_PREL32 */
++    case EM_ADAPTEVA_EPIPHANY:
++      return reloc_type == 6;
++    case EM_ALPHA:
++      return reloc_type == 10; /* R_ALPHA_SREL32.  */
++    case EM_ARC_COMPACT:
++    case EM_ARC_COMPACT2:
++      return reloc_type == 49; /* R_ARC_32_PCREL.  */
++    case EM_ARM:
++      return reloc_type == 3;  /* R_ARM_REL32 */
++    case EM_AVR_OLD:
++    case EM_AVR:
++      return reloc_type == 36; /* R_AVR_32_PCREL.  */
++    case EM_MICROBLAZE:
++      return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
++    case EM_OR1K:
++      return reloc_type == 9; /* R_OR1K_32_PCREL.  */
++    case EM_PARISC:
++      return reloc_type == 9;  /* R_PARISC_PCREL32.  */
++    case EM_PPC:
++      return reloc_type == 26; /* R_PPC_REL32.  */
++    case EM_PPC64:
++      return reloc_type == 26; /* R_PPC64_REL32.  */
++    case EM_RISCV:
++      return reloc_type == 57;	/* R_RISCV_32_PCREL.  */
++    case EM_S390_OLD:
++    case EM_S390:
++      return reloc_type == 5;  /* R_390_PC32.  */
++    case EM_SH:
++      return reloc_type == 2;  /* R_SH_REL32.  */
++    case EM_SPARC32PLUS:
++    case EM_SPARCV9:
++    case EM_SPARC:
++      return reloc_type == 6;  /* R_SPARC_DISP32.  */
++    case EM_SPU:
++      return reloc_type == 13; /* R_SPU_REL32.  */
++    case EM_TILEGX:
++      return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
++    case EM_TILEPRO:
++      return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
++    case EM_VISIUM:
++      return reloc_type == 6;  /* R_VISIUM_32_PCREL */
++    case EM_X86_64:
++    case EM_L1OM:
++    case EM_K1OM:
++      return reloc_type == 2;  /* R_X86_64_PC32.  */
++    case EM_VAX:
++      return reloc_type == 4;  /* R_VAX_PCREL32.  */
++    case EM_XTENSA_OLD:
++    case EM_XTENSA:
++      return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
++    default:
++      /* Do not abort or issue an error message here.  Not all targets use
++	 pc-relative 32-bit relocs in their DWARF debug information and we
++	 have already tested for target coverage in is_32bit_abs_reloc.  A
++	 more helpful warning message will be generated by apply_relocations
++	 anyway, so just return.  */
++      return false;
++    }
++}
++
++/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
++   a 64-bit absolute RELA relocation used in DWARF debug sections.  */
++
++static bool
++is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
++{
++  switch (filedata->file_header.e_machine)
++    {
++    case EM_AARCH64:
++      return reloc_type == 257;	/* R_AARCH64_ABS64.  */
++    case EM_ALPHA:
++      return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
++    case EM_IA_64:
++      return (reloc_type == 0x26    /* R_IA64_DIR64MSB.  */
++	      || reloc_type == 0x27 /* R_IA64_DIR64LSB.  */);
++    case EM_PARISC:
++      return reloc_type == 80; /* R_PARISC_DIR64.  */
++    case EM_PPC64:
++      return reloc_type == 38; /* R_PPC64_ADDR64.  */
++    case EM_RISCV:
++      return reloc_type == 2; /* R_RISCV_64.  */
++    case EM_SPARC32PLUS:
++    case EM_SPARCV9:
++    case EM_SPARC:
++      return reloc_type == 32 /* R_SPARC_64.  */
++	|| reloc_type == 54; /* R_SPARC_UA64.  */
++    case EM_X86_64:
++    case EM_L1OM:
++    case EM_K1OM:
++      return reloc_type == 1; /* R_X86_64_64.  */
++    case EM_S390_OLD:
++    case EM_S390:
++      return reloc_type == 22;	/* R_S390_64.  */
++    case EM_TILEGX:
++      return reloc_type == 1; /* R_TILEGX_64.  */
++    case EM_MIPS:
++      return reloc_type == 18;	/* R_MIPS_64.  */
++    default:
++      return false;
++    }
++}
++
++/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
++   a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
++
++static bool
++is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
++{
++  switch (filedata->file_header.e_machine)
++    {
++    case EM_AARCH64:
++      return reloc_type == 260;	/* R_AARCH64_PREL64.  */
++    case EM_ALPHA:
++      return reloc_type == 11; /* R_ALPHA_SREL64.  */
++    case EM_IA_64:
++      return (reloc_type == 0x4e    /* R_IA64_PCREL64MSB.  */
++	      || reloc_type == 0x4f /* R_IA64_PCREL64LSB.  */);
++    case EM_PARISC:
++      return reloc_type == 72; /* R_PARISC_PCREL64.  */
++    case EM_PPC64:
++      return reloc_type == 44; /* R_PPC64_REL64.  */
++    case EM_SPARC32PLUS:
++    case EM_SPARCV9:
++    case EM_SPARC:
++      return reloc_type == 46; /* R_SPARC_DISP64.  */
++    case EM_X86_64:
++    case EM_L1OM:
++    case EM_K1OM:
++      return reloc_type == 24; /* R_X86_64_PC64.  */
++    case EM_S390_OLD:
++    case EM_S390:
++      return reloc_type == 23;	/* R_S390_PC64.  */
++    case EM_TILEGX:
++      return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
++    default:
++      return false;
++    }
++}
++
++/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
++   a 24-bit absolute RELA relocation used in DWARF debug sections.  */
++
++static bool
++is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
++{
++  switch (filedata->file_header.e_machine)
++    {
++    case EM_CYGNUS_MN10200:
++    case EM_MN10200:
++      return reloc_type == 4; /* R_MN10200_24.  */
++    case EM_FT32:
++      return reloc_type == 5; /* R_FT32_20.  */
++    case EM_Z80:
++      return reloc_type == 5; /* R_Z80_24. */
++    default:
++      return false;
++    }
++}
++
++/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
++   a 16-bit absolute RELA relocation used in DWARF debug sections.  */
++
++static bool
++is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
++{
++  /* Please keep this table alpha-sorted for ease of visual lookup.  */
++  switch (filedata->file_header.e_machine)
++    {
++    case EM_ARC:
++    case EM_ARC_COMPACT:
++    case EM_ARC_COMPACT2:
++      return reloc_type == 2; /* R_ARC_16.  */
++    case EM_ADAPTEVA_EPIPHANY:
++      return reloc_type == 5;
++    case EM_AVR_OLD:
++    case EM_AVR:
++      return reloc_type == 4; /* R_AVR_16.  */
++    case EM_CYGNUS_D10V:
++    case EM_D10V:
++      return reloc_type == 3; /* R_D10V_16.  */
++    case EM_FT32:
++      return reloc_type == 2; /* R_FT32_16.  */
++    case EM_H8S:
++    case EM_H8_300:
++    case EM_H8_300H:
++      return reloc_type == R_H8_DIR16;
++    case EM_IP2K_OLD:
++    case EM_IP2K:
++      return reloc_type == 1; /* R_IP2K_16.  */
++    case EM_M32C_OLD:
++    case EM_M32C:
++      return reloc_type == 1; /* R_M32C_16 */
++    case EM_CYGNUS_MN10200:
++    case EM_MN10200:
++      return reloc_type == 2; /* R_MN10200_16.  */
++    case EM_CYGNUS_MN10300:
++    case EM_MN10300:
++      return reloc_type == 2; /* R_MN10300_16.  */
++    case EM_MSP430:
++      if (uses_msp430x_relocs (filedata))
++	return reloc_type == 2; /* R_MSP430_ABS16.  */
++      /* Fall through.  */
++    case EM_MSP430_OLD:
++      return reloc_type == 5; /* R_MSP430_16_BYTE.  */
++    case EM_NDS32:
++      return reloc_type == 19; /* R_NDS32_RELA.  */
++    case EM_ALTERA_NIOS2:
++      return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
++    case EM_NIOS32:
++      return reloc_type == 9; /* R_NIOS_16.  */
++    case EM_OR1K:
++      return reloc_type == 2; /* R_OR1K_16.  */
++    case EM_RISCV:
++      return reloc_type == 55; /* R_RISCV_SET16.  */
++    case EM_TI_PRU:
++      return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
++    case EM_TI_C6000:
++      return reloc_type == 2; /* R_C6000_ABS16.  */
++    case EM_VISIUM:
++      return reloc_type == 2; /* R_VISIUM_16. */
++    case EM_XC16X:
++    case EM_C166:
++      return reloc_type == 2; /* R_XC16C_ABS_16.  */
++    case EM_XGATE:
++      return reloc_type == 3; /* R_XGATE_16.  */
++    case EM_Z80:
++      return reloc_type == 4; /* R_Z80_16.  */
++    default:
++      return false;
++    }
++}
++
++/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
++   a 8-bit absolute RELA relocation used in DWARF debug sections.  */
++
++static bool
++is_8bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
++{
++  switch (filedata->file_header.e_machine)
++    {
++    case EM_RISCV:
++      return reloc_type == 54; /* R_RISCV_SET8.  */
++    case EM_Z80:
++      return reloc_type == 1;  /* R_Z80_8.  */
++    default:
++      return false;
++    }
++}
++
++/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
++   a 6-bit absolute RELA relocation used in DWARF debug sections.  */
++
++static bool
++is_6bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
++{
++  switch (filedata->file_header.e_machine)
++    {
++    case EM_RISCV:
++      return reloc_type == 53; /* R_RISCV_SET6.  */
++    default:
++      return false;
++    }
++}
++
++/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
++   a 32-bit inplace add RELA relocation used in DWARF debug sections.  */
++
++static bool
++is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
++{
++  /* Please keep this table alpha-sorted for ease of visual lookup.  */
++  switch (filedata->file_header.e_machine)
++    {
++    case EM_RISCV:
++      return reloc_type == 35; /* R_RISCV_ADD32.  */
++    default:
++      return false;
++    }
++}
++
++/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
++   a 32-bit inplace sub RELA relocation used in DWARF debug sections.  */
++
++static bool
++is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
++{
++  /* Please keep this table alpha-sorted for ease of visual lookup.  */
++  switch (filedata->file_header.e_machine)
++    {
++    case EM_RISCV:
++      return reloc_type == 39; /* R_RISCV_SUB32.  */
++    default:
++      return false;
++    }
++}
++
++/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
++   a 64-bit inplace add RELA relocation used in DWARF debug sections.  */
++
++static bool
++is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
++{
++  /* Please keep this table alpha-sorted for ease of visual lookup.  */
++  switch (filedata->file_header.e_machine)
++    {
++    case EM_RISCV:
++      return reloc_type == 36; /* R_RISCV_ADD64.  */
++    default:
++      return false;
++    }
++}
++
++/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
++   a 64-bit inplace sub RELA relocation used in DWARF debug sections.  */
++
++static bool
++is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
++{
++  /* Please keep this table alpha-sorted for ease of visual lookup.  */
++  switch (filedata->file_header.e_machine)
++    {
++    case EM_RISCV:
++      return reloc_type == 40; /* R_RISCV_SUB64.  */
++    default:
++      return false;
++    }
++}
++
++/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
++   a 16-bit inplace add RELA relocation used in DWARF debug sections.  */
++
++static bool
++is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
++{
++  /* Please keep this table alpha-sorted for ease of visual lookup.  */
++  switch (filedata->file_header.e_machine)
++    {
++    case EM_RISCV:
++      return reloc_type == 34; /* R_RISCV_ADD16.  */
++    default:
++      return false;
++    }
++}
++
++/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
++   a 16-bit inplace sub RELA relocation used in DWARF debug sections.  */
++
++static bool
++is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
++{
++  /* Please keep this table alpha-sorted for ease of visual lookup.  */
++  switch (filedata->file_header.e_machine)
++    {
++    case EM_RISCV:
++      return reloc_type == 38; /* R_RISCV_SUB16.  */
++    default:
++      return false;
++    }
++}
++
++/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
++   a 8-bit inplace add RELA relocation used in DWARF debug sections.  */
++
++static bool
++is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
++{
++  /* Please keep this table alpha-sorted for ease of visual lookup.  */
++  switch (filedata->file_header.e_machine)
++    {
++    case EM_RISCV:
++      return reloc_type == 33; /* R_RISCV_ADD8.  */
++    default:
++      return false;
++    }
++}
++
++/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
++   a 8-bit inplace sub RELA relocation used in DWARF debug sections.  */
++
++static bool
++is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
++{
++  /* Please keep this table alpha-sorted for ease of visual lookup.  */
++  switch (filedata->file_header.e_machine)
++    {
++    case EM_RISCV:
++      return reloc_type == 37; /* R_RISCV_SUB8.  */
++    default:
++      return false;
++    }
++}
++
++/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
++   a 6-bit inplace sub RELA relocation used in DWARF debug sections.  */
++
++static bool
++is_6bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
++{
++  switch (filedata->file_header.e_machine)
++    {
++    case EM_RISCV:
++      return reloc_type == 52; /* R_RISCV_SUB6.  */
++    default:
++      return false;
++    }
++}
++
++/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
++   relocation entries (possibly formerly used for SHT_GROUP sections).  */
++
++static bool
++is_none_reloc (Filedata * filedata, unsigned int reloc_type)
++{
++  switch (filedata->file_header.e_machine)
++    {
++    case EM_386:     /* R_386_NONE.  */
++    case EM_68K:     /* R_68K_NONE.  */
++    case EM_ADAPTEVA_EPIPHANY:
++    case EM_ALPHA:   /* R_ALPHA_NONE.  */
++    case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
++    case EM_ARC:     /* R_ARC_NONE.  */
++    case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
++    case EM_ARC_COMPACT: /* R_ARC_NONE.  */
++    case EM_ARM:     /* R_ARM_NONE.  */
++    case EM_C166:    /* R_XC16X_NONE.  */
++    case EM_CRIS:    /* R_CRIS_NONE.  */
++    case EM_FT32:    /* R_FT32_NONE.  */
++    case EM_IA_64:   /* R_IA64_NONE.  */
++    case EM_K1OM:    /* R_X86_64_NONE.  */
++    case EM_L1OM:    /* R_X86_64_NONE.  */
++    case EM_M32R:    /* R_M32R_NONE.  */
++    case EM_MIPS:    /* R_MIPS_NONE.  */
++    case EM_MN10300: /* R_MN10300_NONE.  */
++    case EM_MOXIE:   /* R_MOXIE_NONE.  */
++    case EM_NIOS32:  /* R_NIOS_NONE.  */
++    case EM_OR1K:    /* R_OR1K_NONE. */
++    case EM_PARISC:  /* R_PARISC_NONE.  */
++    case EM_PPC64:   /* R_PPC64_NONE.  */
++    case EM_PPC:     /* R_PPC_NONE.  */
++    case EM_RISCV:   /* R_RISCV_NONE.  */
++    case EM_S390:    /* R_390_NONE.  */
++    case EM_S390_OLD:
++    case EM_SH:      /* R_SH_NONE.  */
++    case EM_SPARC32PLUS:
++    case EM_SPARC:   /* R_SPARC_NONE.  */
++    case EM_SPARCV9:
++    case EM_TILEGX:  /* R_TILEGX_NONE.  */
++    case EM_TILEPRO: /* R_TILEPRO_NONE.  */
++    case EM_TI_C6000:/* R_C6000_NONE.  */
++    case EM_X86_64:  /* R_X86_64_NONE.  */
++    case EM_XC16X:
++    case EM_Z80:     /* R_Z80_NONE. */
++    case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
++      return reloc_type == 0;
++
++    case EM_AARCH64:
++      return reloc_type == 0 || reloc_type == 256;
++    case EM_AVR_OLD:
++    case EM_AVR:
++      return (reloc_type == 0 /* R_AVR_NONE.  */
++	      || reloc_type == 30 /* R_AVR_DIFF8.  */
++	      || reloc_type == 31 /* R_AVR_DIFF16.  */
++	      || reloc_type == 32 /* R_AVR_DIFF32.  */);
++    case EM_METAG:
++      return reloc_type == 3; /* R_METAG_NONE.  */
++    case EM_NDS32:
++      return (reloc_type == 0       /* R_XTENSA_NONE.  */
++	      || reloc_type == 204  /* R_NDS32_DIFF8.  */
++	      || reloc_type == 205  /* R_NDS32_DIFF16.  */
++	      || reloc_type == 206  /* R_NDS32_DIFF32.  */
++	      || reloc_type == 207  /* R_NDS32_ULEB128.  */);
++    case EM_TI_PRU:
++      return (reloc_type == 0       /* R_PRU_NONE.  */
++	      || reloc_type == 65   /* R_PRU_DIFF8.  */
++	      || reloc_type == 66   /* R_PRU_DIFF16.  */
++	      || reloc_type == 67   /* R_PRU_DIFF32.  */);
++    case EM_XTENSA_OLD:
++    case EM_XTENSA:
++      return (reloc_type == 0      /* R_XTENSA_NONE.  */
++	      || reloc_type == 17  /* R_XTENSA_DIFF8.  */
++	      || reloc_type == 18  /* R_XTENSA_DIFF16.  */
++	      || reloc_type == 19  /* R_XTENSA_DIFF32.  */
++	      || reloc_type == 57  /* R_XTENSA_PDIFF8.  */
++	      || reloc_type == 58  /* R_XTENSA_PDIFF16.  */
++	      || reloc_type == 59  /* R_XTENSA_PDIFF32.  */
++	      || reloc_type == 60  /* R_XTENSA_NDIFF8.  */
++	      || reloc_type == 61  /* R_XTENSA_NDIFF16.  */
++	      || reloc_type == 62  /* R_XTENSA_NDIFF32.  */);
++    }
++  return false;
++}
++
++/* Returns TRUE if there is a relocation against
++   section NAME at OFFSET bytes.  */
++
++bool
++reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
++{
++  Elf_Internal_Rela * relocs;
++  Elf_Internal_Rela * rp;
++
++  if (dsec == NULL || dsec->reloc_info == NULL)
++    return false;
++
++  relocs = (Elf_Internal_Rela *) dsec->reloc_info;
++
++  for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
++    if (rp->r_offset == offset)
++      return true;
++
++   return false;
++}
++
++/* Apply relocations to a section.
++   Returns TRUE upon success, FALSE otherwise.
++   If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
++   It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
++   will be set to the number of relocs loaded.
++
++   Note: So far support has been added only for those relocations
++   which can be found in debug sections. FIXME: Add support for
++   more relocations ?  */
++
++static bool
++apply_relocations (Filedata *                 filedata,
++		   const Elf_Internal_Shdr *  section,
++		   unsigned char *            start,
++		   bfd_size_type              size,
++		   void **                    relocs_return,
++		   unsigned long *            num_relocs_return)
++{
++  Elf_Internal_Shdr * relsec;
++  unsigned char * end = start + size;
++
++  if (relocs_return != NULL)
++    {
++      * (Elf_Internal_Rela **) relocs_return = NULL;
++      * num_relocs_return = 0;
++    }
++
++  if (filedata->file_header.e_type != ET_REL)
++    /* No relocs to apply.  */
++    return true;
++
++  /* Find the reloc section associated with the section.  */
++  for (relsec = filedata->section_headers;
++       relsec < filedata->section_headers + filedata->file_header.e_shnum;
++       ++relsec)
++    {
++      bool is_rela;
++      unsigned long num_relocs;
++      Elf_Internal_Rela * relocs;
++      Elf_Internal_Rela * rp;
++      Elf_Internal_Shdr * symsec;
++      Elf_Internal_Sym * symtab;
++      unsigned long num_syms;
++      Elf_Internal_Sym * sym;
++
++      if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
++	  || relsec->sh_info >= filedata->file_header.e_shnum
++	  || filedata->section_headers + relsec->sh_info != section
++	  || relsec->sh_size == 0
++	  || relsec->sh_link >= filedata->file_header.e_shnum)
++	continue;
++
++      symsec = filedata->section_headers + relsec->sh_link;
++      if (symsec->sh_type != SHT_SYMTAB
++	  && symsec->sh_type != SHT_DYNSYM)
++	return false;
++
++      is_rela = relsec->sh_type == SHT_RELA;
++
++      if (is_rela)
++	{
++	  if (!slurp_rela_relocs (filedata, relsec->sh_offset,
++                                  relsec->sh_size, & relocs, & num_relocs))
++	    return false;
++	}
++      else
++	{
++	  if (!slurp_rel_relocs (filedata, relsec->sh_offset,
++                                 relsec->sh_size, & relocs, & num_relocs))
++	    return false;
++	}
++
++      /* SH uses RELA but uses in place value instead of the addend field.  */
++      if (filedata->file_header.e_machine == EM_SH)
++	is_rela = false;
++
++      symtab = get_elf_symbols (filedata, symsec, & num_syms);
++
++      for (rp = relocs; rp < relocs + num_relocs; ++rp)
++	{
++	  bfd_vma addend;
++	  unsigned int reloc_type;
++	  unsigned int reloc_size;
++	  bool reloc_inplace = false;
++	  bool reloc_subtract = false;
++	  unsigned char *rloc;
++	  unsigned long sym_index;
++
++	  reloc_type = get_reloc_type (filedata, rp->r_info);
++
++	  if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
++	    continue;
++	  else if (is_none_reloc (filedata, reloc_type))
++	    continue;
++	  else if (is_32bit_abs_reloc (filedata, reloc_type)
++		   || is_32bit_pcrel_reloc (filedata, reloc_type))
++	    reloc_size = 4;
++	  else if (is_64bit_abs_reloc (filedata, reloc_type)
++		   || is_64bit_pcrel_reloc (filedata, reloc_type))
++	    reloc_size = 8;
++	  else if (is_24bit_abs_reloc (filedata, reloc_type))
++	    reloc_size = 3;
++	  else if (is_16bit_abs_reloc (filedata, reloc_type))
++	    reloc_size = 2;
++	  else if (is_8bit_abs_reloc (filedata, reloc_type)
++		   || is_6bit_abs_reloc (filedata, reloc_type))
++	    reloc_size = 1;
++	  else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
++								 reloc_type))
++		   || is_32bit_inplace_add_reloc (filedata, reloc_type))
++	    {
++	      reloc_size = 4;
++	      reloc_inplace = true;
++	    }
++	  else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
++								 reloc_type))
++		   || is_64bit_inplace_add_reloc (filedata, reloc_type))
++	    {
++	      reloc_size = 8;
++	      reloc_inplace = true;
++	    }
++	  else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
++								 reloc_type))
++		   || is_16bit_inplace_add_reloc (filedata, reloc_type))
++	    {
++	      reloc_size = 2;
++	      reloc_inplace = true;
++	    }
++	  else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
++								reloc_type))
++		   || is_8bit_inplace_add_reloc (filedata, reloc_type))
++	    {
++	      reloc_size = 1;
++	      reloc_inplace = true;
++	    }
++	  else if ((reloc_subtract = is_6bit_inplace_sub_reloc (filedata,
++								reloc_type)))
++	    {
++	      reloc_size = 1;
++	      reloc_inplace = true;
++	    }
++	  else
++	    {
++	      static unsigned int prev_reloc = 0;
++
++	      if (reloc_type != prev_reloc)
++		warn (_("unable to apply unsupported reloc type %d to section %s\n"),
++		      reloc_type, printable_section_name (filedata, section));
++	      prev_reloc = reloc_type;
++	      continue;
++	    }
++
++	  rloc = start + rp->r_offset;
++	  if (!IN_RANGE (start, end, rloc, reloc_size))
++	    {
++	      warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
++		    (unsigned long) rp->r_offset,
++		    printable_section_name (filedata, section));
++	      continue;
++	    }
++
++	  sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
++	  if (sym_index >= num_syms)
++	    {
++	      warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
++		    sym_index, printable_section_name (filedata, section));
++	      continue;
++	    }
++	  sym = symtab + sym_index;
++
++	  /* If the reloc has a symbol associated with it,
++	     make sure that it is of an appropriate type.
++
++	     Relocations against symbols without type can happen.
++	     Gcc -feliminate-dwarf2-dups may generate symbols
++	     without type for debug info.
++
++	     Icc generates relocations against function symbols
++	     instead of local labels.
++
++	     Relocations against object symbols can happen, eg when
++	     referencing a global array.  For an example of this see
++	     the _clz.o binary in libgcc.a.  */
++	  if (sym != symtab
++	      && ELF_ST_TYPE (sym->st_info) != STT_COMMON
++	      && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
++	    {
++	      warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
++		    get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
++		    printable_section_name (filedata, relsec),
++		    (long int)(rp - relocs));
++	      continue;
++	    }
++
++	  addend = 0;
++	  if (is_rela)
++	    addend += rp->r_addend;
++	  /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
++	     partial_inplace.  */
++	  if (!is_rela
++	      || (filedata->file_header.e_machine == EM_XTENSA
++		  && reloc_type == 1)
++	      || ((filedata->file_header.e_machine == EM_PJ
++		   || filedata->file_header.e_machine == EM_PJ_OLD)
++		  && reloc_type == 1)
++	      || ((filedata->file_header.e_machine == EM_D30V
++		   || filedata->file_header.e_machine == EM_CYGNUS_D30V)
++		  && reloc_type == 12)
++	      || reloc_inplace)
++	    {
++	      if (is_6bit_inplace_sub_reloc (filedata, reloc_type))
++		addend += byte_get (rloc, reloc_size) & 0x3f;
++	      else
++		addend += byte_get (rloc, reloc_size);
++	    }
++
++	  if (is_32bit_pcrel_reloc (filedata, reloc_type)
++	      || is_64bit_pcrel_reloc (filedata, reloc_type))
++	    {
++	      /* On HPPA, all pc-relative relocations are biased by 8.  */
++	      if (filedata->file_header.e_machine == EM_PARISC)
++		addend -= 8;
++	      byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
++		        reloc_size);
++	    }
++	  else if (is_6bit_abs_reloc (filedata, reloc_type)
++		   || is_6bit_inplace_sub_reloc (filedata, reloc_type))
++	    {
++	      if (reloc_subtract)
++		addend -= sym->st_value;
++	      else
++		addend += sym->st_value;
++	      addend = (addend & 0x3f) | (byte_get (rloc, reloc_size) & 0xc0);
++	      byte_put (rloc, addend, reloc_size);
++	    }
++	  else if (reloc_subtract)
++	    byte_put (rloc, addend - sym->st_value, reloc_size);
++	  else
++	    byte_put (rloc, addend + sym->st_value, reloc_size);
++	}
++
++      free (symtab);
++      /* Let the target specific reloc processing code know that
++	 we have finished with these relocs.  */
++      target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
++
++      if (relocs_return)
++	{
++	  * (Elf_Internal_Rela **) relocs_return = relocs;
++	  * num_relocs_return = num_relocs;
++	}
++      else
++	free (relocs);
++
++      break;
++    }
++
++  return true;
++}
++
++#ifdef SUPPORT_DISASSEMBLY
++static bool
++disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
++{
++  printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
++
++  /* FIXME: XXX -- to be done --- XXX */
++
++  return true;
++}
++#endif
++
++/* Reads in the contents of SECTION from FILE, returning a pointer
++   to a malloc'ed buffer or NULL if something went wrong.  */
++
++static char *
++get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
++{
++  bfd_size_type num_bytes = section->sh_size;
++
++  if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
++    {
++      printf (_("Section '%s' has no data to dump.\n"),
++	      printable_section_name (filedata, section));
++      return NULL;
++    }
++
++  return  (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
++                             _("section contents"));
++}
++
++/* Uncompresses a section that was compressed using zlib, in place.  */
++
++static bool
++uncompress_section_contents (unsigned char **   buffer,
++			     dwarf_size_type    uncompressed_size,
++			     dwarf_size_type *  size)
++{
++  dwarf_size_type compressed_size = *size;
++  unsigned char * compressed_buffer = *buffer;
++  unsigned char * uncompressed_buffer;
++  z_stream strm;
++  int rc;
++
++  /* It is possible the section consists of several compressed
++     buffers concatenated together, so we uncompress in a loop.  */
++  /* PR 18313: The state field in the z_stream structure is supposed
++     to be invisible to the user (ie us), but some compilers will
++     still complain about it being used without initialisation.  So
++     we first zero the entire z_stream structure and then set the fields
++     that we need.  */
++  memset (& strm, 0, sizeof strm);
++  strm.avail_in = compressed_size;
++  strm.next_in = (Bytef *) compressed_buffer;
++  strm.avail_out = uncompressed_size;
++  uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
++
++  rc = inflateInit (& strm);
++  while (strm.avail_in > 0)
++    {
++      if (rc != Z_OK)
++        break;
++      strm.next_out = ((Bytef *) uncompressed_buffer
++                       + (uncompressed_size - strm.avail_out));
++      rc = inflate (&strm, Z_FINISH);
++      if (rc != Z_STREAM_END)
++        break;
++      rc = inflateReset (& strm);
++    }
++  if (inflateEnd (& strm) != Z_OK
++      || rc != Z_OK
++      || strm.avail_out != 0)
++    goto fail;
++
++  *buffer = uncompressed_buffer;
++  *size = uncompressed_size;
++  return true;
++
++ fail:
++  free (uncompressed_buffer);
++  /* Indicate decompression failure.  */
++  *buffer = NULL;
++  return false;
++}
++
++static bool
++dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
++{
++  Elf_Internal_Shdr *relsec;
++  bfd_size_type num_bytes;
++  unsigned char *data;
++  unsigned char *end;
++  unsigned char *real_start;
++  unsigned char *start;
++  bool some_strings_shown;
++
++  real_start = start = (unsigned char *) get_section_contents (section, filedata);
++  if (start == NULL)
++    /* PR 21820: Do not fail if the section was empty.  */
++    return section->sh_size == 0 || section->sh_type == SHT_NOBITS;
++
++  num_bytes = section->sh_size;
++
++  if (filedata->is_separate)
++    printf (_("\nString dump of section '%s' in linked file %s:\n"),
++	    printable_section_name (filedata, section),
++	    filedata->file_name);
++  else
++    printf (_("\nString dump of section '%s':\n"),
++	    printable_section_name (filedata, section));
++
++  if (decompress_dumps)
++    {
++      dwarf_size_type new_size = num_bytes;
++      dwarf_size_type uncompressed_size = 0;
++
++      if ((section->sh_flags & SHF_COMPRESSED) != 0)
++	{
++	  Elf_Internal_Chdr chdr;
++	  unsigned int compression_header_size
++	    = get_compression_header (& chdr, (unsigned char *) start,
++				      num_bytes);
++	  if (compression_header_size == 0)
++	    /* An error message will have already been generated
++	       by get_compression_header.  */
++	    goto error_out;
++
++	  if (chdr.ch_type != ELFCOMPRESS_ZLIB)
++	    {
++	      warn (_("section '%s' has unsupported compress type: %d\n"),
++		    printable_section_name (filedata, section), chdr.ch_type);
++	      goto error_out;
++	    }
++	  uncompressed_size = chdr.ch_size;
++	  start += compression_header_size;
++	  new_size -= compression_header_size;
++	}
++      else if (new_size > 12 && streq ((char *) start, "ZLIB"))
++	{
++	  /* Read the zlib header.  In this case, it should be "ZLIB"
++	     followed by the uncompressed section size, 8 bytes in
++	     big-endian order.  */
++	  uncompressed_size = start[4]; uncompressed_size <<= 8;
++	  uncompressed_size += start[5]; uncompressed_size <<= 8;
++	  uncompressed_size += start[6]; uncompressed_size <<= 8;
++	  uncompressed_size += start[7]; uncompressed_size <<= 8;
++	  uncompressed_size += start[8]; uncompressed_size <<= 8;
++	  uncompressed_size += start[9]; uncompressed_size <<= 8;
++	  uncompressed_size += start[10]; uncompressed_size <<= 8;
++	  uncompressed_size += start[11];
++	  start += 12;
++	  new_size -= 12;
++	}
++
++      if (uncompressed_size)
++	{
++	  if (uncompress_section_contents (& start,
++					   uncompressed_size, & new_size))
++	    num_bytes = new_size;
++	  else
++	    {
++	      error (_("Unable to decompress section %s\n"),
++		     printable_section_name (filedata, section));
++	      goto error_out;
++	    }
++	}
++      else
++	start = real_start;
++    }
++
++  /* If the section being dumped has relocations against it the user might
++     be expecting these relocations to have been applied.  Check for this
++     case and issue a warning message in order to avoid confusion.
++     FIXME: Maybe we ought to have an option that dumps a section with
++     relocs applied ?  */
++  for (relsec = filedata->section_headers;
++       relsec < filedata->section_headers + filedata->file_header.e_shnum;
++       ++relsec)
++    {
++      if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
++	  || relsec->sh_info >= filedata->file_header.e_shnum
++	  || filedata->section_headers + relsec->sh_info != section
++	  || relsec->sh_size == 0
++	  || relsec->sh_link >= filedata->file_header.e_shnum)
++	continue;
++
++      printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
++      break;
++    }
++
++  data = start;
++  end  = start + num_bytes;
++  some_strings_shown = false;
++
++#ifdef HAVE_MBSTATE_T
++  mbstate_t state;
++  /* Initialise the multibyte conversion state.  */
++  memset (& state, 0, sizeof (state));
++#endif
++
++  bool continuing = false;
++
++  while (data < end)
++    {
++      while (!ISPRINT (* data))
++	if (++ data >= end)
++	  break;
++
++      if (data < end)
++	{
++	  size_t maxlen = end - data;
++
++	  if (continuing)
++	    {
++	      printf ("            ");
++	      continuing = false;
++	    }
++	  else
++	    {
++	      printf ("  [%6lx]  ", (unsigned long) (data - start));
++	    }
++
++	  if (maxlen > 0)
++	    {
++	      char c = 0;
++
++	      while (maxlen)
++		{
++		  c = *data++;
++
++		  if (c == 0)
++		    break;
++
++		  /* PR 25543: Treat new-lines as string-ending characters.  */
++		  if (c == '\n')
++		    {
++		      printf ("\\n\n");
++		      if (*data != 0)
++			continuing = true;
++		      break;
++		    }
++
++		  /* Do not print control characters directly as they can affect terminal
++		     settings.  Such characters usually appear in the names generated
++		     by the assembler for local labels.  */
++		  if (ISCNTRL (c))
++		    {
++		      printf ("^%c", c + 0x40);
++		    }
++		  else if (ISPRINT (c))
++		    {
++		      putchar (c);
++		    }
++		  else
++		    {
++		      size_t  n;
++#ifdef HAVE_MBSTATE_T
++		      wchar_t w;
++#endif
++		      /* Let printf do the hard work of displaying multibyte characters.  */
++		      printf ("%.1s", data - 1);
++#ifdef HAVE_MBSTATE_T
++		      /* Try to find out how many bytes made up the character that was
++			 just printed.  Advance the symbol pointer past the bytes that
++			 were displayed.  */
++		      n = mbrtowc (& w, (char *)(data - 1), MB_CUR_MAX, & state);
++#else
++		      n = 1;
++#endif
++		      if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
++			data += (n - 1);
++		    }
++		}
++
++	      if (c != '\n')
++		putchar ('\n');
++	    }
++	  else
++	    {
++	      printf (_("<corrupt>\n"));
++	      data = end;
++	    }
++	  some_strings_shown = true;
++	}
++    }
++
++  if (! some_strings_shown)
++    printf (_("  No strings found in this section."));
++
++  free (real_start);
++
++  putchar ('\n');
++  return true;
++
++error_out:
++  free (real_start);
++  return false;
++}
++
++static bool
++dump_section_as_bytes (Elf_Internal_Shdr *section,
++		       Filedata *filedata,
++		       bool relocate)
++{
++  Elf_Internal_Shdr * relsec;
++  bfd_size_type       bytes;
++  bfd_size_type       section_size;
++  bfd_vma             addr;
++  unsigned char *     data;
++  unsigned char *     real_start;
++  unsigned char *     start;
++
++  real_start = start = (unsigned char *) get_section_contents (section, filedata);
++  if (start == NULL)
++    /* PR 21820: Do not fail if the section was empty.  */
++    return section->sh_size == 0 || section->sh_type == SHT_NOBITS;
++
++  section_size = section->sh_size;
++
++  if (filedata->is_separate)
++    printf (_("\nHex dump of section '%s' in linked file %s:\n"),
++	    printable_section_name (filedata, section),
++	    filedata->file_name);
++  else
++    printf (_("\nHex dump of section '%s':\n"),
++	    printable_section_name (filedata, section));
++
++  if (decompress_dumps)
++    {
++      dwarf_size_type new_size = section_size;
++      dwarf_size_type uncompressed_size = 0;
++
++      if ((section->sh_flags & SHF_COMPRESSED) != 0)
++	{
++	  Elf_Internal_Chdr chdr;
++	  unsigned int compression_header_size
++	    = get_compression_header (& chdr, start, section_size);
++
++	  if (compression_header_size == 0)
++	    /* An error message will have already been generated
++	       by get_compression_header.  */
++	    goto error_out;
++
++	  if (chdr.ch_type != ELFCOMPRESS_ZLIB)
++	    {
++	      warn (_("section '%s' has unsupported compress type: %d\n"),
++		    printable_section_name (filedata, section), chdr.ch_type);
++	      goto error_out;
++	    }
++	  uncompressed_size = chdr.ch_size;
++	  start += compression_header_size;
++	  new_size -= compression_header_size;
++	}
++      else if (new_size > 12 && streq ((char *) start, "ZLIB"))
++	{
++	  /* Read the zlib header.  In this case, it should be "ZLIB"
++	     followed by the uncompressed section size, 8 bytes in
++	     big-endian order.  */
++	  uncompressed_size = start[4]; uncompressed_size <<= 8;
++	  uncompressed_size += start[5]; uncompressed_size <<= 8;
++	  uncompressed_size += start[6]; uncompressed_size <<= 8;
++	  uncompressed_size += start[7]; uncompressed_size <<= 8;
++	  uncompressed_size += start[8]; uncompressed_size <<= 8;
++	  uncompressed_size += start[9]; uncompressed_size <<= 8;
++	  uncompressed_size += start[10]; uncompressed_size <<= 8;
++	  uncompressed_size += start[11];
++	  start += 12;
++	  new_size -= 12;
++	}
++
++      if (uncompressed_size)
++	{
++	  if (uncompress_section_contents (& start, uncompressed_size,
++					   & new_size))
++	    {
++	      section_size = new_size;
++	    }
++	  else
++	    {
++	      error (_("Unable to decompress section %s\n"),
++		     printable_section_name (filedata, section));
++	      /* FIXME: Print the section anyway ?  */
++	      goto error_out;
++	    }
++	}
++      else
++	start = real_start;
++    }
++
++  if (relocate)
++    {
++      if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
++	goto error_out;
++    }
++  else
++    {
++      /* If the section being dumped has relocations against it the user might
++	 be expecting these relocations to have been applied.  Check for this
++	 case and issue a warning message in order to avoid confusion.
++	 FIXME: Maybe we ought to have an option that dumps a section with
++	 relocs applied ?  */
++      for (relsec = filedata->section_headers;
++	   relsec < filedata->section_headers + filedata->file_header.e_shnum;
++	   ++relsec)
++	{
++	  if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
++	      || relsec->sh_info >= filedata->file_header.e_shnum
++	      || filedata->section_headers + relsec->sh_info != section
++	      || relsec->sh_size == 0
++	      || relsec->sh_link >= filedata->file_header.e_shnum)
++	    continue;
++
++	  printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
++	  break;
++	}
++    }
++
++  addr = section->sh_addr;
++  bytes = section_size;
++  data = start;
++
++  while (bytes)
++    {
++      int j;
++      int k;
++      int lbytes;
++
++      lbytes = (bytes > 16 ? 16 : bytes);
++
++      printf ("  0x%8.8lx ", (unsigned long) addr);
++
++      for (j = 0; j < 16; j++)
++	{
++	  if (j < lbytes)
++	    printf ("%2.2x", data[j]);
++	  else
++	    printf ("  ");
++
++	  if ((j & 3) == 3)
++	    printf (" ");
++	}
++
++      for (j = 0; j < lbytes; j++)
++	{
++	  k = data[j];
++	  if (k >= ' ' && k < 0x7f)
++	    printf ("%c", k);
++	  else
++	    printf (".");
++	}
++
++      putchar ('\n');
++
++      data  += lbytes;
++      addr  += lbytes;
++      bytes -= lbytes;
++    }
++
++  free (real_start);
++
++  putchar ('\n');
++  return true;
++
++ error_out:
++  free (real_start);
++  return false;
++}
++
++#ifdef ENABLE_LIBCTF
++static ctf_sect_t *
++shdr_to_ctf_sect (ctf_sect_t *buf, Elf_Internal_Shdr *shdr, Filedata *filedata)
++{
++  buf->cts_name = SECTION_NAME_PRINT (shdr);
++  buf->cts_size = shdr->sh_size;
++  buf->cts_entsize = shdr->sh_entsize;
++
++  return buf;
++}
++
++/* 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;
++}
++
++/* 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)
++    {
++      error (_("%s: %s"), is_warning ? _("warning"): _("error"),
++	     errtext);
++      free (errtext);
++    }
++  if (err != ECTF_NEXT_END)
++    error (_("CTF error: cannot get CTF errors: `%s'"), ctf_errmsg (err));
++}
++
++/* Dump one CTF archive member.  */
++
++static int
++dump_ctf_archive_member (ctf_dict_t *ctf, const char *name, void *arg)
++{
++  ctf_dict_t *parent = (ctf_dict_t *) arg;
++  const char *things[] = {"Header", "Labels", "Data objects",
++			  "Function objects", "Variables", "Types", "Strings",
++			  ""};
++  const char **thing;
++  size_t i;
++  int err = 0;
++
++  /* Only print out the name of non-default-named archive members.
++     The name .ctf appears everywhere, even for things that aren't
++     really archives, so printing it out is liable to be confusing.
++
++     The parent, if there is one, is the default-owned archive member:
++     avoid importing it into itself.  (This does no harm, but looks
++     confusing.)  */
++
++  if (strcmp (name, ".ctf") != 0)
++    {
++      printf (_("\nCTF archive member: %s:\n"), name);
++      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))
++	{
++	  error (_("Iteration failed: %s, %s\n"), *thing,
++		 ctf_errmsg (ctf_errno (ctf)));
++	  err = 1;
++	  goto out;
++	}
++    }
++
++ out:
++  dump_ctf_errs (ctf);
++  return err;
++}
++
++static bool
++dump_section_as_ctf (Elf_Internal_Shdr * section, Filedata * filedata)
++{
++  Elf_Internal_Shdr *  parent_sec = NULL;
++  Elf_Internal_Shdr *  symtab_sec = NULL;
++  Elf_Internal_Shdr *  strtab_sec = NULL;
++  void *	       data = NULL;
++  void *	       symdata = NULL;
++  void *	       strdata = NULL;
++  void *	       parentdata = NULL;
++  ctf_sect_t	       ctfsect, symsect, strsect, parentsect;
++  ctf_sect_t *	       symsectp = NULL;
++  ctf_sect_t *	       strsectp = NULL;
++  ctf_archive_t *      ctfa = NULL;
++  ctf_archive_t *      parenta = NULL, *lookparent;
++  ctf_dict_t *         parent = NULL;
++
++  int err;
++  bool ret = false;
++
++  shdr_to_ctf_sect (&ctfsect, section, filedata);
++  data = get_section_contents (section, filedata);
++  ctfsect.cts_data = data;
++
++  if (!dump_ctf_symtab_name)
++    dump_ctf_symtab_name = strdup (".dynsym");
++
++  if (!dump_ctf_strtab_name)
++    dump_ctf_strtab_name = strdup (".dynstr");
++
++  if (dump_ctf_symtab_name && dump_ctf_symtab_name[0] != 0)
++    {
++      if ((symtab_sec = find_section (filedata, dump_ctf_symtab_name)) == NULL)
++	{
++	  error (_("No symbol section named %s\n"), dump_ctf_symtab_name);
++	  goto fail;
++	}
++      if ((symdata = (void *) get_data (NULL, filedata,
++					symtab_sec->sh_offset, 1,
++					symtab_sec->sh_size,
++					_("symbols"))) == NULL)
++	goto fail;
++      symsectp = shdr_to_ctf_sect (&symsect, symtab_sec, filedata);
++      symsect.cts_data = symdata;
++    }
++
++  if (dump_ctf_strtab_name && dump_ctf_strtab_name[0] != 0)
++    {
++      if ((strtab_sec = find_section (filedata, dump_ctf_strtab_name)) == NULL)
++	{
++	  error (_("No string table section named %s\n"),
++		 dump_ctf_strtab_name);
++	  goto fail;
++	}
++      if ((strdata = (void *) get_data (NULL, filedata,
++					strtab_sec->sh_offset, 1,
++					strtab_sec->sh_size,
++					_("strings"))) == NULL)
++	goto fail;
++      strsectp = shdr_to_ctf_sect (&strsect, strtab_sec, filedata);
++      strsect.cts_data = strdata;
++    }
++
++  if (dump_ctf_parent_name)
++    {
++      if ((parent_sec = find_section (filedata, dump_ctf_parent_name)) == NULL)
++	{
++	  error (_("No CTF parent section named %s\n"), dump_ctf_parent_name);
++	  goto fail;
++	}
++      if ((parentdata = (void *) get_data (NULL, filedata,
++					   parent_sec->sh_offset, 1,
++					   parent_sec->sh_size,
++					   _("CTF parent"))) == NULL)
++	goto fail;
++      shdr_to_ctf_sect (&parentsect, parent_sec, filedata);
++      parentsect.cts_data = parentdata;
++    }
++
++  /* Load the CTF file and dump it.  It may be a raw CTF section, or an archive:
++     libctf papers over the difference, so we can pretend it is always an
++     archive.  Possibly open the parent as well, if one was specified.  */
++
++  if ((ctfa = ctf_arc_bufopen (&ctfsect, symsectp, strsectp, &err)) == NULL)
++    {
++      dump_ctf_errs (NULL);
++      error (_("CTF open failure: %s\n"), ctf_errmsg (err));
++      goto fail;
++    }
++
++  ctf_arc_symsect_endianness (ctfa, filedata->file_header.e_ident[EI_DATA]
++			      != ELFDATA2MSB);
++
++  if (parentdata)
++    {
++      if ((parenta = ctf_arc_bufopen (&parentsect, symsectp, strsectp,
++				      &err)) == NULL)
++	{
++	  dump_ctf_errs (NULL);
++	  error (_("CTF open failure: %s\n"), ctf_errmsg (err));
++	  goto fail;
++	}
++      lookparent = parenta;
++    }
++  else
++    lookparent = ctfa;
++
++  /* Assume that the applicable parent archive member is the default one.
++     (This is what all known implementations are expected to do, if they
++     put CTFs and their parents in archives together.)  */
++  if ((parent = ctf_dict_open (lookparent, NULL, &err)) == NULL)
++    {
++      dump_ctf_errs (NULL);
++      error (_("CTF open failure: %s\n"), ctf_errmsg (err));
++      goto fail;
++    }
++
++  ret = true;
++
++  if (filedata->is_separate)
++    printf (_("\nDump of CTF section '%s' in linked file %s:\n"),
++	    printable_section_name (filedata, section),
++	    filedata->file_name);
++  else
++    printf (_("\nDump of CTF section '%s':\n"),
++	    printable_section_name (filedata, section));
++
++  if ((err = ctf_archive_iter (ctfa, dump_ctf_archive_member, parent)) != 0)
++    {
++      dump_ctf_errs (NULL);
++      error (_("CTF member open failure: %s\n"), ctf_errmsg (err));
++      ret = false;
++    }
++
++ fail:
++  ctf_dict_close (parent);
++  ctf_close (ctfa);
++  ctf_close (parenta);
++  free (parentdata);
++  free (data);
++  free (symdata);
++  free (strdata);
++  return ret;
++}
++#endif
++
++static bool
++load_specific_debug_section (enum dwarf_section_display_enum  debug,
++			     const Elf_Internal_Shdr *        sec,
++			     void *                           data)
++{
++  struct dwarf_section * section = &debug_displays [debug].section;
++  char buf [64];
++  Filedata * filedata = (Filedata *) data;
++
++  if (section->start != NULL)
++    {
++      /* If it is already loaded, do nothing.  */
++      if (streq (section->filename, filedata->file_name))
++	return true;
++      free (section->start);
++    }
++
++  snprintf (buf, sizeof (buf), _("%s section data"), section->name);
++  section->address = sec->sh_addr;
++  section->filename = filedata->file_name;
++  section->start = (unsigned char *) get_data (NULL, filedata,
++                                               sec->sh_offset, 1,
++                                               sec->sh_size, buf);
++  if (section->start == NULL)
++    section->size = 0;
++  else
++    {
++      unsigned char *start = section->start;
++      dwarf_size_type size = sec->sh_size;
++      dwarf_size_type uncompressed_size = 0;
++
++      if ((sec->sh_flags & SHF_COMPRESSED) != 0)
++	{
++	  Elf_Internal_Chdr chdr;
++	  unsigned int compression_header_size;
++
++	  if (size < (is_32bit_elf
++		      ? sizeof (Elf32_External_Chdr)
++		      : sizeof (Elf64_External_Chdr)))
++	    {
++	      warn (_("compressed section %s is too small to contain a compression header\n"),
++		    section->name);
++	      return false;
++	    }
++
++	  compression_header_size = get_compression_header (&chdr, start, size);
++	  if (compression_header_size == 0)
++	    /* An error message will have already been generated
++	       by get_compression_header.  */
++	    return false;
++
++	  if (chdr.ch_type != ELFCOMPRESS_ZLIB)
++	    {
++	      warn (_("section '%s' has unsupported compress type: %d\n"),
++		    section->name, chdr.ch_type);
++	      return false;
++	    }
++	  uncompressed_size = chdr.ch_size;
++	  start += compression_header_size;
++	  size -= compression_header_size;
++	}
++      else if (size > 12 && streq ((char *) start, "ZLIB"))
++	{
++	  /* Read the zlib header.  In this case, it should be "ZLIB"
++	     followed by the uncompressed section size, 8 bytes in
++	     big-endian order.  */
++	  uncompressed_size = start[4]; uncompressed_size <<= 8;
++	  uncompressed_size += start[5]; uncompressed_size <<= 8;
++	  uncompressed_size += start[6]; uncompressed_size <<= 8;
++	  uncompressed_size += start[7]; uncompressed_size <<= 8;
++	  uncompressed_size += start[8]; uncompressed_size <<= 8;
++	  uncompressed_size += start[9]; uncompressed_size <<= 8;
++	  uncompressed_size += start[10]; uncompressed_size <<= 8;
++	  uncompressed_size += start[11];
++	  start += 12;
++	  size -= 12;
++	}
++
++      if (uncompressed_size)
++	{
++	  if (uncompress_section_contents (&start, uncompressed_size,
++					   &size))
++	    {
++	      /* Free the compressed buffer, update the section buffer
++		 and the section size if uncompress is successful.  */
++	      free (section->start);
++	      section->start = start;
++	    }
++	  else
++	    {
++	      error (_("Unable to decompress section %s\n"),
++		     printable_section_name (filedata, sec));
++	      return false;
++	    }
++	}
++
++      section->size = size;
++    }
++
++  if (section->start == NULL)
++    return false;
++
++  if (debug_displays [debug].relocate)
++    {
++      if (! apply_relocations (filedata, sec, section->start, section->size,
++			       & section->reloc_info, & section->num_relocs))
++	return false;
++    }
++  else
++    {
++      section->reloc_info = NULL;
++      section->num_relocs = 0;
++    }
++
++  return true;
++}
++
++#if HAVE_LIBDEBUGINFOD
++/* Return a hex string representation of the build-id.  */
++unsigned char *
++get_build_id (void * data)
++{
++  Filedata * filedata = (Filedata *) data;
++  Elf_Internal_Shdr * shdr;
++  unsigned long i;
++
++  /* Iterate through notes to find note.gnu.build-id.
++     FIXME: Only the first note in any note section is examined.  */
++  for (i = 0, shdr = filedata->section_headers;
++       i < filedata->file_header.e_shnum && shdr != NULL;
++       i++, shdr++)
++    {
++      if (shdr->sh_type != SHT_NOTE)
++        continue;
++
++      char * next;
++      char * end;
++      size_t data_remaining;
++      size_t min_notesz;
++      Elf_External_Note * enote;
++      Elf_Internal_Note inote;
++
++      bfd_vma offset = shdr->sh_offset;
++      bfd_vma align = shdr->sh_addralign;
++      bfd_vma length = shdr->sh_size;
++
++      enote = (Elf_External_Note *) get_section_contents (shdr, filedata);
++      if (enote == NULL)
++        continue;
++
++      if (align < 4)
++        align = 4;
++      else if (align != 4 && align != 8)
++	{
++	  free (enote);
++	  continue;
++	}
++
++      end = (char *) enote + length;
++      data_remaining = end - (char *) enote;
++
++      if (!is_ia64_vms (filedata))
++        {
++          min_notesz = offsetof (Elf_External_Note, name);
++          if (data_remaining < min_notesz)
++            {
++	      warn (_("\
++malformed note encountered in section %s whilst scanning for build-id note\n"),
++		    printable_section_name (filedata, shdr));
++	      free (enote);
++              continue;
++            }
++          data_remaining -= min_notesz;
++
++          inote.type     = BYTE_GET (enote->type);
++          inote.namesz   = BYTE_GET (enote->namesz);
++          inote.namedata = enote->name;
++          inote.descsz   = BYTE_GET (enote->descsz);
++          inote.descdata = ((char *) enote
++                            + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
++          inote.descpos  = offset + (inote.descdata - (char *) enote);
++          next = ((char *) enote
++                  + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
++        }
++      else
++        {
++          Elf64_External_VMS_Note *vms_enote;
++
++          /* PR binutils/15191
++             Make sure that there is enough data to read.  */
++          min_notesz = offsetof (Elf64_External_VMS_Note, name);
++          if (data_remaining < min_notesz)
++            {
++	      warn (_("\
++malformed note encountered in section %s whilst scanning for build-id note\n"),
++		    printable_section_name (filedata, shdr));
++	      free (enote);
++              continue;
++            }
++          data_remaining -= min_notesz;
++
++          vms_enote = (Elf64_External_VMS_Note *) enote;
++          inote.type     = BYTE_GET (vms_enote->type);
++          inote.namesz   = BYTE_GET (vms_enote->namesz);
++          inote.namedata = vms_enote->name;
++          inote.descsz   = BYTE_GET (vms_enote->descsz);
++          inote.descdata = inote.namedata + align_power (inote.namesz, 3);
++          inote.descpos  = offset + (inote.descdata - (char *) enote);
++          next = inote.descdata + align_power (inote.descsz, 3);
++        }
++
++      /* Skip malformed notes.  */
++      if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
++          || (size_t) (inote.descdata - inote.namedata) > data_remaining
++          || (size_t) (next - inote.descdata) < inote.descsz
++          || ((size_t) (next - inote.descdata)
++              > data_remaining - (size_t) (inote.descdata - inote.namedata)))
++        {
++	  warn (_("\
++malformed note encountered in section %s whilst scanning for build-id note\n"),
++		printable_section_name (filedata, shdr));
++	  free (enote);
++          continue;
++        }
++
++      /* Check if this is the build-id note. If so then convert the build-id
++         bytes to a hex string.  */
++      if (inote.namesz > 0
++          && startswith (inote.namedata, "GNU")
++          && inote.type == NT_GNU_BUILD_ID)
++        {
++          unsigned long j;
++          char * build_id;
++
++          build_id = malloc (inote.descsz * 2 + 1);
++          if (build_id == NULL)
++	    {
++	      free (enote);
++	      return NULL;
++	    }
++
++          for (j = 0; j < inote.descsz; ++j)
++            sprintf (build_id + (j * 2), "%02x", inote.descdata[j] & 0xff);
++          build_id[inote.descsz * 2] = '\0';
++	  free (enote);
++
++          return (unsigned char *) build_id;
++        }
++      free (enote);
++    }
++
++  return NULL;
++}
++#endif /* HAVE_LIBDEBUGINFOD */
++
++/* If this is not NULL, load_debug_section will only look for sections
++   within the list of sections given here.  */
++static unsigned int * section_subset = NULL;
++
++bool
++load_debug_section (enum dwarf_section_display_enum debug, void * data)
++{
++  struct dwarf_section * section = &debug_displays [debug].section;
++  Elf_Internal_Shdr * sec;
++  Filedata * filedata = (Filedata *) data;
++
++  /* Without section headers we cannot find any sections.  */
++  if (filedata->section_headers == NULL)
++    return false;
++
++  if (filedata->string_table == NULL
++      && filedata->file_header.e_shstrndx != SHN_UNDEF
++      && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
++    {
++      Elf_Internal_Shdr * strs;
++
++      /* Read in the string table, so that we have section names to scan.  */
++      strs = filedata->section_headers + filedata->file_header.e_shstrndx;
++
++      if (strs != NULL && strs->sh_size != 0)
++	{
++	  filedata->string_table
++	    = (char *) get_data (NULL, filedata, strs->sh_offset,
++				 1, strs->sh_size, _("string table"));
++
++	  filedata->string_table_length
++	    = filedata->string_table != NULL ? strs->sh_size : 0;
++	}
++    }
++
++  /* Locate the debug section.  */
++  sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
++  if (sec != NULL)
++    section->name = section->uncompressed_name;
++  else
++    {
++      sec = find_section_in_set (filedata, section->compressed_name, section_subset);
++      if (sec != NULL)
++	section->name = section->compressed_name;
++    }
++  if (sec == NULL)
++    return false;
++
++  /* If we're loading from a subset of sections, and we've loaded
++     a section matching this name before, it's likely that it's a
++     different one.  */
++  if (section_subset != NULL)
++    free_debug_section (debug);
++
++  return load_specific_debug_section (debug, sec, data);
++}
++
++void
++free_debug_section (enum dwarf_section_display_enum debug)
++{
++  struct dwarf_section * section = &debug_displays [debug].section;
++
++  if (section->start == NULL)
++    return;
++
++  free ((char *) section->start);
++  section->start = NULL;
++  section->address = 0;
++  section->size = 0;
++
++  free (section->reloc_info);
++  section->reloc_info = NULL;
++  section->num_relocs = 0;
++}
++
++static bool
++display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
++{
++  char * name = SECTION_NAME_VALID (section) ? SECTION_NAME (section) : "";
++  const char * print_name = printable_section_name (filedata, section);
++  bfd_size_type length;
++  bool result = true;
++  int i;
++
++  length = section->sh_size;
++  if (length == 0)
++    {
++      printf (_("\nSection '%s' has no debugging data.\n"), print_name);
++      return true;
++    }
++  if (section->sh_type == SHT_NOBITS)
++    {
++      /* There is no point in dumping the contents of a debugging section
++	 which has the NOBITS type - the bits in the file will be random.
++	 This can happen when a file containing a .eh_frame section is
++	 stripped with the --only-keep-debug command line option.  */
++      printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
++	      print_name);
++      return false;
++    }
++
++  if (startswith (name, ".gnu.linkonce.wi."))
++    name = ".debug_info";
++
++  /* See if we know how to display the contents of this section.  */
++  for (i = 0; i < max; i++)
++    {
++      enum dwarf_section_display_enum  id = (enum dwarf_section_display_enum) i;
++      struct dwarf_section_display *   display = debug_displays + i;
++      struct dwarf_section *           sec = & display->section;
++
++      if (streq (sec->uncompressed_name, name)
++	  || (id == line && startswith (name, ".debug_line."))
++	  || streq (sec->compressed_name, name))
++	{
++	  bool secondary = (section != find_section (filedata, name));
++
++	  if (secondary)
++	    free_debug_section (id);
++
++	  if (i == line && startswith (name, ".debug_line."))
++	    sec->name = name;
++	  else if (streq (sec->uncompressed_name, name))
++	    sec->name = sec->uncompressed_name;
++	  else
++	    sec->name = sec->compressed_name;
++
++	  if (load_specific_debug_section (id, section, filedata))
++	    {
++	      /* If this debug section is part of a CU/TU set in a .dwp file,
++		 restrict load_debug_section to the sections in that set.  */
++	      section_subset = find_cu_tu_set (filedata, shndx);
++
++	      result &= display->display (sec, filedata);
++
++	      section_subset = NULL;
++
++	      if (secondary || (id != info && id != abbrev && id != debug_addr))
++		free_debug_section (id);
++	    }
++	  break;
++	}
++    }
++
++  if (i == max)
++    {
++      printf (_("Unrecognized debug section: %s\n"), print_name);
++      result = false;
++    }
++
++  return result;
++}
++
++/* Set DUMP_SECTS for all sections where dumps were requested
++   based on section name.  */
++
++static void
++initialise_dumps_byname (Filedata * filedata)
++{
++  struct dump_list_entry * cur;
++
++  for (cur = dump_sects_byname; cur; cur = cur->next)
++    {
++      unsigned int i;
++      bool any = false;
++
++      for (i = 0; i < filedata->file_header.e_shnum; i++)
++	if (SECTION_NAME_VALID (filedata->section_headers + i)
++	    && streq (SECTION_NAME (filedata->section_headers + i), cur->name))
++	  {
++	    request_dump_bynumber (&filedata->dump, i, cur->type);
++	    any = true;
++	  }
++
++      if (!any && !filedata->is_separate)
++	warn (_("Section '%s' was not dumped because it does not exist\n"),
++	      cur->name);
++    }
++}
++
++static bool
++process_section_contents (Filedata * filedata)
++{
++  Elf_Internal_Shdr * section;
++  unsigned int i;
++  bool res = true;
++
++  if (! do_dump)
++    return true;
++
++  initialise_dumps_byname (filedata);
++
++  for (i = 0, section = filedata->section_headers;
++       i < filedata->file_header.e_shnum && i < filedata->dump.num_dump_sects;
++       i++, section++)
++    {
++      dump_type dump = filedata->dump.dump_sects[i];
++
++      if (filedata->is_separate && ! process_links)
++	dump &= DEBUG_DUMP;
++
++#ifdef SUPPORT_DISASSEMBLY
++      if (dump & DISASS_DUMP)
++	{
++	  if (! disassemble_section (section, filedata))
++	    res = false;
++	}
++#endif
++      if (dump & HEX_DUMP)
++	{
++	  if (! dump_section_as_bytes (section, filedata, false))
++	    res = false;
++	}
++
++      if (dump & RELOC_DUMP)
++	{
++	  if (! dump_section_as_bytes (section, filedata, true))
++	    res = false;
++	}
++
++      if (dump & STRING_DUMP)
++	{
++	  if (! dump_section_as_strings (section, filedata))
++	    res = false;
++	}
++
++      if (dump & DEBUG_DUMP)
++	{
++	  if (! display_debug_section (i, section, filedata))
++	    res = false;
++	}
++
++#ifdef ENABLE_LIBCTF
++      if (dump & CTF_DUMP)
++	{
++	  if (! dump_section_as_ctf (section, filedata))
++	    res = false;
++	}
++#endif
++    }
++
++  if (! filedata->is_separate)
++    {
++      /* Check to see if the user requested a
++	 dump of a section that does not exist.  */
++      for (; i < filedata->dump.num_dump_sects; i++)
++	if (filedata->dump.dump_sects[i])
++	  {
++	    warn (_("Section %d was not dumped because it does not exist!\n"), i);
++	    res = false;
++	  }
++    }
++
++  return res;
++}
++
++static void
++process_mips_fpe_exception (int mask)
++{
++  if (mask)
++    {
++      bool first = true;
++
++      if (mask & OEX_FPU_INEX)
++	fputs ("INEX", stdout), first = false;
++      if (mask & OEX_FPU_UFLO)
++	printf ("%sUFLO", first ? "" : "|"), first = false;
++      if (mask & OEX_FPU_OFLO)
++	printf ("%sOFLO", first ? "" : "|"), first = false;
++      if (mask & OEX_FPU_DIV0)
++	printf ("%sDIV0", first ? "" : "|"), first = false;
++      if (mask & OEX_FPU_INVAL)
++	printf ("%sINVAL", first ? "" : "|");
++    }
++  else
++    fputs ("0", stdout);
++}
++
++/* Display's the value of TAG at location P.  If TAG is
++   greater than 0 it is assumed to be an unknown tag, and
++   a message is printed to this effect.  Otherwise it is
++   assumed that a message has already been printed.
++
++   If the bottom bit of TAG is set it assumed to have a
++   string value, otherwise it is assumed to have an integer
++   value.
++
++   Returns an updated P pointing to the first unread byte
++   beyond the end of TAG's value.
++
++   Reads at or beyond END will not be made.  */
++
++static unsigned char *
++display_tag_value (signed int tag,
++		   unsigned char * p,
++		   const unsigned char * const end)
++{
++  unsigned long val;
++
++  if (tag > 0)
++    printf ("  Tag_unknown_%d: ", tag);
++
++  if (p >= end)
++    {
++      warn (_("<corrupt tag>\n"));
++    }
++  else if (tag & 1)
++    {
++      /* PR 17531 file: 027-19978-0.004.  */
++      size_t maxlen = (end - p) - 1;
++
++      putchar ('"');
++      if (maxlen > 0)
++	{
++	  print_symbol ((int) maxlen, (const char *) p);
++	  p += strnlen ((char *) p, maxlen) + 1;
++	}
++      else
++	{
++	  printf (_("<corrupt string tag>"));
++	  p = (unsigned char *) end;
++	}
++      printf ("\"\n");
++    }
++  else
++    {
++      READ_ULEB (val, p, end);
++      printf ("%ld (0x%lx)\n", val, val);
++    }
++
++  assert (p <= end);
++  return p;
++}
++
++/* ARC ABI attributes section.  */
++
++static unsigned char *
++display_arc_attribute (unsigned char * p,
++		       const unsigned char * const end)
++{
++  unsigned int tag;
++  unsigned int val;
++
++  READ_ULEB (tag, p, end);
++
++  switch (tag)
++    {
++    case Tag_ARC_PCS_config:
++      READ_ULEB (val, p, end);
++      printf ("  Tag_ARC_PCS_config: ");
++      switch (val)
++	{
++	case 0:
++	  printf (_("Absent/Non standard\n"));
++	  break;
++	case 1:
++	  printf (_("Bare metal/mwdt\n"));
++	  break;
++	case 2:
++	  printf (_("Bare metal/newlib\n"));
++	  break;
++	case 3:
++	  printf (_("Linux/uclibc\n"));
++	  break;
++	case 4:
++	  printf (_("Linux/glibc\n"));
++	  break;
++	default:
++	  printf (_("Unknown\n"));
++	  break;
++	}
++      break;
++
++    case Tag_ARC_CPU_base:
++      READ_ULEB (val, p, end);
++      printf ("  Tag_ARC_CPU_base: ");
++      switch (val)
++	{
++	default:
++	case TAG_CPU_NONE:
++	  printf (_("Absent\n"));
++	  break;
++	case TAG_CPU_ARC6xx:
++	  printf ("ARC6xx\n");
++	  break;
++	case TAG_CPU_ARC7xx:
++	  printf ("ARC7xx\n");
++	  break;
++	case TAG_CPU_ARCEM:
++	  printf ("ARCEM\n");
++	  break;
++	case TAG_CPU_ARCHS:
++	  printf ("ARCHS\n");
++	  break;
++	}
++      break;
++
++    case Tag_ARC_CPU_variation:
++      READ_ULEB (val, p, end);
++      printf ("  Tag_ARC_CPU_variation: ");
++      switch (val)
++	{
++	default:
++	  if (val > 0 && val < 16)
++	      printf ("Core%d\n", val);
++	  else
++	      printf ("Unknown\n");
++	  break;
++
++	case 0:
++	  printf (_("Absent\n"));
++	  break;
++	}
++      break;
++
++    case Tag_ARC_CPU_name:
++      printf ("  Tag_ARC_CPU_name: ");
++      p = display_tag_value (-1, p, end);
++      break;
++
++    case Tag_ARC_ABI_rf16:
++      READ_ULEB (val, p, end);
++      printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
++      break;
++
++    case Tag_ARC_ABI_osver:
++      READ_ULEB (val, p, end);
++      printf ("  Tag_ARC_ABI_osver: v%d\n", val);
++      break;
++
++    case Tag_ARC_ABI_pic:
++    case Tag_ARC_ABI_sda:
++      READ_ULEB (val, p, end);
++      printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
++	      : "  Tag_ARC_ABI_pic: ");
++      switch (val)
++	{
++	case 0:
++	  printf (_("Absent\n"));
++	  break;
++	case 1:
++	  printf ("MWDT\n");
++	  break;
++	case 2:
++	  printf ("GNU\n");
++	  break;
++	default:
++	  printf (_("Unknown\n"));
++	  break;
++	}
++      break;
++
++    case Tag_ARC_ABI_tls:
++      READ_ULEB (val, p, end);
++      printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
++      break;
++
++    case Tag_ARC_ABI_enumsize:
++      READ_ULEB (val, p, end);
++      printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
++	      _("smallest"));
++      break;
++
++    case Tag_ARC_ABI_exceptions:
++      READ_ULEB (val, p, end);
++      printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
++	      : _("default"));
++      break;
++
++    case Tag_ARC_ABI_double_size:
++      READ_ULEB (val, p, end);
++      printf ("  Tag_ARC_ABI_double_size: %d\n", val);
++      break;
++
++    case Tag_ARC_ISA_config:
++      printf ("  Tag_ARC_ISA_config: ");
++      p = display_tag_value (-1, p, end);
++      break;
++
++    case Tag_ARC_ISA_apex:
++      printf ("  Tag_ARC_ISA_apex: ");
++      p = display_tag_value (-1, p, end);
++      break;
++
++    case Tag_ARC_ISA_mpy_option:
++      READ_ULEB (val, p, end);
++      printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
++      break;
++
++    case Tag_ARC_ATR_version:
++      READ_ULEB (val, p, end);
++      printf ("  Tag_ARC_ATR_version: %d\n", val);
++      break;
++
++    default:
++      return display_tag_value (tag & 1, p, end);
++    }
++
++  return p;
++}
++
++/* ARM EABI attributes section.  */
++typedef struct
++{
++  unsigned int tag;
++  const char * name;
++  /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
++  unsigned int type;
++  const char *const *table;
++} arm_attr_public_tag;
++
++static const char *const arm_attr_tag_CPU_arch[] =
++  {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
++   "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
++   "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
++static const char *const arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
++static const char *const arm_attr_tag_THUMB_ISA_use[] =
++  {"No", "Thumb-1", "Thumb-2", "Yes"};
++static const char *const arm_attr_tag_FP_arch[] =
++  {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
++   "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
++static const char *const arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
++static const char *const arm_attr_tag_Advanced_SIMD_arch[] =
++  {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
++   "NEON for ARMv8.1"};
++static const char *const arm_attr_tag_PCS_config[] =
++  {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
++   "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
++static const char *const arm_attr_tag_ABI_PCS_R9_use[] =
++  {"V6", "SB", "TLS", "Unused"};
++static const char *const arm_attr_tag_ABI_PCS_RW_data[] =
++  {"Absolute", "PC-relative", "SB-relative", "None"};
++static const char *const arm_attr_tag_ABI_PCS_RO_data[] =
++  {"Absolute", "PC-relative", "None"};
++static const char *const arm_attr_tag_ABI_PCS_GOT_use[] =
++  {"None", "direct", "GOT-indirect"};
++static const char *const arm_attr_tag_ABI_PCS_wchar_t[] =
++  {"None", "??? 1", "2", "??? 3", "4"};
++static const char *const arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
++static const char *const arm_attr_tag_ABI_FP_denormal[] =
++  {"Unused", "Needed", "Sign only"};
++static const char *const arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
++static const char *const arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
++static const char *const arm_attr_tag_ABI_FP_number_model[] =
++  {"Unused", "Finite", "RTABI", "IEEE 754"};
++static const char *const arm_attr_tag_ABI_enum_size[] =
++  {"Unused", "small", "int", "forced to int"};
++static const char *const arm_attr_tag_ABI_HardFP_use[] =
++  {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
++static const char *const arm_attr_tag_ABI_VFP_args[] =
++  {"AAPCS", "VFP registers", "custom", "compatible"};
++static const char *const arm_attr_tag_ABI_WMMX_args[] =
++  {"AAPCS", "WMMX registers", "custom"};
++static const char *const arm_attr_tag_ABI_optimization_goals[] =
++  {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
++    "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
++static const char *const arm_attr_tag_ABI_FP_optimization_goals[] =
++  {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
++    "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
++static const char *const arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
++static const char *const arm_attr_tag_FP_HP_extension[] =
++  {"Not Allowed", "Allowed"};
++static const char *const arm_attr_tag_ABI_FP_16bit_format[] =
++  {"None", "IEEE 754", "Alternative Format"};
++static const char *const arm_attr_tag_DSP_extension[] =
++  {"Follow architecture", "Allowed"};
++static const char *const arm_attr_tag_MPextension_use[] =
++  {"Not Allowed", "Allowed"};
++static const char *const arm_attr_tag_DIV_use[] =
++  {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
++    "Allowed in v7-A with integer division extension"};
++static const char *const arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
++static const char *const arm_attr_tag_Virtualization_use[] =
++  {"Not Allowed", "TrustZone", "Virtualization Extensions",
++    "TrustZone and Virtualization Extensions"};
++static const char *const arm_attr_tag_MPextension_use_legacy[] =
++  {"Not Allowed", "Allowed"};
++
++static const char *const arm_attr_tag_MVE_arch[] =
++  {"No MVE", "MVE Integer only", "MVE Integer and FP"};
++
++#define LOOKUP(id, name) \
++  {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
++static arm_attr_public_tag arm_attr_public_tags[] =
++{
++  {4, "CPU_raw_name", 1, NULL},
++  {5, "CPU_name", 1, NULL},
++  LOOKUP(6, CPU_arch),
++  {7, "CPU_arch_profile", 0, NULL},
++  LOOKUP(8, ARM_ISA_use),
++  LOOKUP(9, THUMB_ISA_use),
++  LOOKUP(10, FP_arch),
++  LOOKUP(11, WMMX_arch),
++  LOOKUP(12, Advanced_SIMD_arch),
++  LOOKUP(13, PCS_config),
++  LOOKUP(14, ABI_PCS_R9_use),
++  LOOKUP(15, ABI_PCS_RW_data),
++  LOOKUP(16, ABI_PCS_RO_data),
++  LOOKUP(17, ABI_PCS_GOT_use),
++  LOOKUP(18, ABI_PCS_wchar_t),
++  LOOKUP(19, ABI_FP_rounding),
++  LOOKUP(20, ABI_FP_denormal),
++  LOOKUP(21, ABI_FP_exceptions),
++  LOOKUP(22, ABI_FP_user_exceptions),
++  LOOKUP(23, ABI_FP_number_model),
++  {24, "ABI_align_needed", 0, NULL},
++  {25, "ABI_align_preserved", 0, NULL},
++  LOOKUP(26, ABI_enum_size),
++  LOOKUP(27, ABI_HardFP_use),
++  LOOKUP(28, ABI_VFP_args),
++  LOOKUP(29, ABI_WMMX_args),
++  LOOKUP(30, ABI_optimization_goals),
++  LOOKUP(31, ABI_FP_optimization_goals),
++  {32, "compatibility", 0, NULL},
++  LOOKUP(34, CPU_unaligned_access),
++  LOOKUP(36, FP_HP_extension),
++  LOOKUP(38, ABI_FP_16bit_format),
++  LOOKUP(42, MPextension_use),
++  LOOKUP(44, DIV_use),
++  LOOKUP(46, DSP_extension),
++  LOOKUP(48, MVE_arch),
++  {64, "nodefaults", 0, NULL},
++  {65, "also_compatible_with", 0, NULL},
++  LOOKUP(66, T2EE_use),
++  {67, "conformance", 1, NULL},
++  LOOKUP(68, Virtualization_use),
++  LOOKUP(70, MPextension_use_legacy)
++};
++#undef LOOKUP
++
++static unsigned char *
++display_arm_attribute (unsigned char * p,
++		       const unsigned char * const end)
++{
++  unsigned int tag;
++  unsigned int val;
++  arm_attr_public_tag * attr;
++  unsigned i;
++  unsigned int type;
++
++  READ_ULEB (tag, p, end);
++  attr = NULL;
++  for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
++    {
++      if (arm_attr_public_tags[i].tag == tag)
++	{
++	  attr = &arm_attr_public_tags[i];
++	  break;
++	}
++    }
++
++  if (attr)
++    {
++      printf ("  Tag_%s: ", attr->name);
++      switch (attr->type)
++	{
++	case 0:
++	  switch (tag)
++	    {
++	    case 7: /* Tag_CPU_arch_profile.  */
++	      READ_ULEB (val, p, end);
++	      switch (val)
++		{
++		case 0: printf (_("None\n")); break;
++		case 'A': printf (_("Application\n")); break;
++		case 'R': printf (_("Realtime\n")); break;
++		case 'M': printf (_("Microcontroller\n")); break;
++		case 'S': printf (_("Application or Realtime\n")); break;
++		default: printf ("??? (%d)\n", val); break;
++		}
++	      break;
++
++	    case 24: /* Tag_align_needed.  */
++	      READ_ULEB (val, p, end);
++	      switch (val)
++		{
++		case 0: printf (_("None\n")); break;
++		case 1: printf (_("8-byte\n")); break;
++		case 2: printf (_("4-byte\n")); break;
++		case 3: printf ("??? 3\n"); break;
++		default:
++		  if (val <= 12)
++		    printf (_("8-byte and up to %d-byte extended\n"),
++			    1 << val);
++		  else
++		    printf ("??? (%d)\n", val);
++		  break;
++		}
++	      break;
++
++	    case 25: /* Tag_align_preserved.  */
++	      READ_ULEB (val, p, end);
++	      switch (val)
++		{
++		case 0: printf (_("None\n")); break;
++		case 1: printf (_("8-byte, except leaf SP\n")); break;
++		case 2: printf (_("8-byte\n")); break;
++		case 3: printf ("??? 3\n"); break;
++		default:
++		  if (val <= 12)
++		    printf (_("8-byte and up to %d-byte extended\n"),
++			    1 << val);
++		  else
++		    printf ("??? (%d)\n", val);
++		  break;
++		}
++	      break;
++
++	    case 32: /* Tag_compatibility.  */
++	      {
++		READ_ULEB (val, p, end);
++		printf (_("flag = %d, vendor = "), val);
++		if (p < end - 1)
++		  {
++		    size_t maxlen = (end - p) - 1;
++
++		    print_symbol ((int) maxlen, (const char *) p);
++		    p += strnlen ((char *) p, maxlen) + 1;
++		  }
++		else
++		  {
++		    printf (_("<corrupt>"));
++		    p = (unsigned char *) end;
++		  }
++		putchar ('\n');
++	      }
++	      break;
++
++	    case 64: /* Tag_nodefaults.  */
++	      /* PR 17531: file: 001-505008-0.01.  */
++	      if (p < end)
++		p++;
++	      printf (_("True\n"));
++	      break;
++
++	    case 65: /* Tag_also_compatible_with.  */
++	      READ_ULEB (val, p, end);
++	      if (val == 6 /* Tag_CPU_arch.  */)
++		{
++		  READ_ULEB (val, p, end);
++		  if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
++		    printf ("??? (%d)\n", val);
++		  else
++		    printf ("%s\n", arm_attr_tag_CPU_arch[val]);
++		}
++	      else
++		printf ("???\n");
++	      while (p < end && *(p++) != '\0' /* NUL terminator.  */)
++		;
++	      break;
++
++	    default:
++	      printf (_("<unknown: %d>\n"), tag);
++	      break;
++	    }
++	  return p;
++
++	case 1:
++	  return display_tag_value (-1, p, end);
++	case 2:
++	  return display_tag_value (0, p, end);
++
++	default:
++	  assert (attr->type & 0x80);
++	  READ_ULEB (val, p, end);
++	  type = attr->type & 0x7f;
++	  if (val >= type)
++	    printf ("??? (%d)\n", val);
++	  else
++	    printf ("%s\n", attr->table[val]);
++	  return p;
++	}
++    }
++
++  return display_tag_value (tag, p, end);
++}
++
++static unsigned char *
++display_gnu_attribute (unsigned char * p,
++		       unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
++		       const unsigned char * const end)
++{
++  unsigned int tag;
++  unsigned int val;
++
++  READ_ULEB (tag, p, end);
++
++  /* Tag_compatibility is the only generic GNU attribute defined at
++     present.  */
++  if (tag == 32)
++    {
++      READ_ULEB (val, p, end);
++
++      printf (_("flag = %d, vendor = "), val);
++      if (p == end)
++	{
++	  printf (_("<corrupt>\n"));
++	  warn (_("corrupt vendor attribute\n"));
++	}
++      else
++	{
++	  if (p < end - 1)
++	    {
++	      size_t maxlen = (end - p) - 1;
++
++	      print_symbol ((int) maxlen, (const char *) p);
++	      p += strnlen ((char *) p, maxlen) + 1;
++	    }
++	  else
++	    {
++	      printf (_("<corrupt>"));
++	      p = (unsigned char *) end;
++	    }
++	  putchar ('\n');
++	}
++      return p;
++    }
++
++  if ((tag & 2) == 0 && display_proc_gnu_attribute)
++    return display_proc_gnu_attribute (p, tag, end);
++
++  return display_tag_value (tag, p, end);
++}
++
++static unsigned char *
++display_m68k_gnu_attribute (unsigned char * p,
++			    unsigned int tag,
++			    const unsigned char * const end)
++{
++  unsigned int val;
++
++  if (tag == Tag_GNU_M68K_ABI_FP)
++    {
++      printf ("  Tag_GNU_M68K_ABI_FP: ");
++      if (p == end)
++	{
++	  printf (_("<corrupt>\n"));
++	  return p;
++	}
++      READ_ULEB (val, p, end);
++
++      if (val > 3)
++	printf ("(%#x), ", val);
++
++      switch (val & 3)
++	{
++	case 0:
++	  printf (_("unspecified hard/soft float\n"));
++	  break;
++	case 1:
++	  printf (_("hard float\n"));
++	  break;
++	case 2:
++	  printf (_("soft float\n"));
++	  break;
++	}
++      return p;
++    }
++
++  return display_tag_value (tag & 1, p, end);
++}
++
++static unsigned char *
++display_power_gnu_attribute (unsigned char * p,
++			     unsigned int tag,
++			     const unsigned char * const end)
++{
++  unsigned int val;
++
++  if (tag == Tag_GNU_Power_ABI_FP)
++    {
++      printf ("  Tag_GNU_Power_ABI_FP: ");
++      if (p == end)
++	{
++	  printf (_("<corrupt>\n"));
++	  return p;
++	}
++      READ_ULEB (val, p, end);
++
++      if (val > 15)
++	printf ("(%#x), ", val);
++
++      switch (val & 3)
++	{
++	case 0:
++	  printf (_("unspecified hard/soft float, "));
++	  break;
++	case 1:
++	  printf (_("hard float, "));
++	  break;
++	case 2:
++	  printf (_("soft float, "));
++	  break;
++	case 3:
++	  printf (_("single-precision hard float, "));
++	  break;
++	}
++
++      switch (val & 0xC)
++	{
++	case 0:
++	  printf (_("unspecified long double\n"));
++	  break;
++	case 4:
++	  printf (_("128-bit IBM long double\n"));
++	  break;
++	case 8:
++	  printf (_("64-bit long double\n"));
++	  break;
++	case 12:
++	  printf (_("128-bit IEEE long double\n"));
++	  break;
++	}
++      return p;
++    }
++
++  if (tag == Tag_GNU_Power_ABI_Vector)
++    {
++      printf ("  Tag_GNU_Power_ABI_Vector: ");
++      if (p == end)
++	{
++	  printf (_("<corrupt>\n"));
++	  return p;
++	}
++      READ_ULEB (val, p, end);
++
++      if (val > 3)
++	printf ("(%#x), ", val);
++
++      switch (val & 3)
++	{
++	case 0:
++	  printf (_("unspecified\n"));
++	  break;
++	case 1:
++	  printf (_("generic\n"));
++	  break;
++	case 2:
++	  printf ("AltiVec\n");
++	  break;
++	case 3:
++	  printf ("SPE\n");
++	  break;
++	}
++      return p;
++    }
++
++  if (tag == Tag_GNU_Power_ABI_Struct_Return)
++    {
++      printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
++      if (p == end)
++	{
++	  printf (_("<corrupt>\n"));
++	  return p;
++	}
++      READ_ULEB (val, p, end);
++
++      if (val > 2)
++	printf ("(%#x), ", val);
++
++      switch (val & 3)
++	{
++	case 0:
++	  printf (_("unspecified\n"));
++	  break;
++	case 1:
++	  printf ("r3/r4\n");
++	  break;
++	case 2:
++	  printf (_("memory\n"));
++	  break;
++	case 3:
++	  printf ("???\n");
++	  break;
++	}
++      return p;
++    }
++
++  return display_tag_value (tag & 1, p, end);
++}
++
++static unsigned char *
++display_s390_gnu_attribute (unsigned char * p,
++			    unsigned int tag,
++			    const unsigned char * const end)
++{
++  unsigned int val;
++
++  if (tag == Tag_GNU_S390_ABI_Vector)
++    {
++      printf ("  Tag_GNU_S390_ABI_Vector: ");
++      READ_ULEB (val, p, end);
++
++      switch (val)
++	{
++	case 0:
++	  printf (_("any\n"));
++	  break;
++	case 1:
++	  printf (_("software\n"));
++	  break;
++	case 2:
++	  printf (_("hardware\n"));
++	  break;
++	default:
++	  printf ("??? (%d)\n", val);
++	  break;
++	}
++      return p;
++   }
++
++  return display_tag_value (tag & 1, p, end);
++}
++
++static void
++display_sparc_hwcaps (unsigned int mask)
++{
++  if (mask)
++    {
++      bool first = true;
++
++      if (mask & ELF_SPARC_HWCAP_MUL32)
++	fputs ("mul32", stdout), first = false;
++      if (mask & ELF_SPARC_HWCAP_DIV32)
++	printf ("%sdiv32", first ? "" : "|"), first = false;
++      if (mask & ELF_SPARC_HWCAP_FSMULD)
++	printf ("%sfsmuld", first ? "" : "|"), first = false;
++      if (mask & ELF_SPARC_HWCAP_V8PLUS)
++	printf ("%sv8plus", first ? "" : "|"), first = false;
++      if (mask & ELF_SPARC_HWCAP_POPC)
++	printf ("%spopc", first ? "" : "|"), first = false;
++      if (mask & ELF_SPARC_HWCAP_VIS)
++	printf ("%svis", first ? "" : "|"), first = false;
++      if (mask & ELF_SPARC_HWCAP_VIS2)
++	printf ("%svis2", first ? "" : "|"), first = false;
++      if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
++	printf ("%sASIBlkInit", first ? "" : "|"), first = false;
++      if (mask & ELF_SPARC_HWCAP_FMAF)
++	printf ("%sfmaf", first ? "" : "|"), first = false;
++      if (mask & ELF_SPARC_HWCAP_VIS3)
++	printf ("%svis3", first ? "" : "|"), first = false;
++      if (mask & ELF_SPARC_HWCAP_HPC)
++	printf ("%shpc", first ? "" : "|"), first = false;
++      if (mask & ELF_SPARC_HWCAP_RANDOM)
++	printf ("%srandom", first ? "" : "|"), first = false;
++      if (mask & ELF_SPARC_HWCAP_TRANS)
++	printf ("%strans", first ? "" : "|"), first = false;
++      if (mask & ELF_SPARC_HWCAP_FJFMAU)
++	printf ("%sfjfmau", first ? "" : "|"), first = false;
++      if (mask & ELF_SPARC_HWCAP_IMA)
++	printf ("%sima", first ? "" : "|"), first = false;
++      if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
++	printf ("%scspare", first ? "" : "|"), first = false;
++    }
++  else
++    fputc ('0', stdout);
++  fputc ('\n', stdout);
++}
++
++static void
++display_sparc_hwcaps2 (unsigned int mask)
++{
++  if (mask)
++    {
++      bool first = true;
++
++      if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
++	fputs ("fjathplus", stdout), first = false;
++      if (mask & ELF_SPARC_HWCAP2_VIS3B)
++	printf ("%svis3b", first ? "" : "|"), first = false;
++      if (mask & ELF_SPARC_HWCAP2_ADP)
++	printf ("%sadp", first ? "" : "|"), first = false;
++      if (mask & ELF_SPARC_HWCAP2_SPARC5)
++	printf ("%ssparc5", first ? "" : "|"), first = false;
++      if (mask & ELF_SPARC_HWCAP2_MWAIT)
++	printf ("%smwait", first ? "" : "|"), first = false;
++      if (mask & ELF_SPARC_HWCAP2_XMPMUL)
++	printf ("%sxmpmul", first ? "" : "|"), first = false;
++      if (mask & ELF_SPARC_HWCAP2_XMONT)
++	printf ("%sxmont2", first ? "" : "|"), first = false;
++      if (mask & ELF_SPARC_HWCAP2_NSEC)
++	printf ("%snsec", first ? "" : "|"), first = false;
++      if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
++	printf ("%sfjathhpc", first ? "" : "|"), first = false;
++      if (mask & ELF_SPARC_HWCAP2_FJDES)
++	printf ("%sfjdes", first ? "" : "|"), first = false;
++      if (mask & ELF_SPARC_HWCAP2_FJAES)
++	printf ("%sfjaes", first ? "" : "|"), first = false;
++    }
++  else
++    fputc ('0', stdout);
++  fputc ('\n', stdout);
++}
++
++static unsigned char *
++display_sparc_gnu_attribute (unsigned char * p,
++			     unsigned int tag,
++			     const unsigned char * const end)
++{
++  unsigned int val;
++
++  if (tag == Tag_GNU_Sparc_HWCAPS)
++    {
++      READ_ULEB (val, p, end);
++      printf ("  Tag_GNU_Sparc_HWCAPS: ");
++      display_sparc_hwcaps (val);
++      return p;
++    }
++  if (tag == Tag_GNU_Sparc_HWCAPS2)
++    {
++      READ_ULEB (val, p, end);
++      printf ("  Tag_GNU_Sparc_HWCAPS2: ");
++      display_sparc_hwcaps2 (val);
++      return p;
++    }
++
++  return display_tag_value (tag, p, end);
++}
++
++static void
++print_mips_fp_abi_value (unsigned int val)
++{
++  switch (val)
++    {
++    case Val_GNU_MIPS_ABI_FP_ANY:
++      printf (_("Hard or soft float\n"));
++      break;
++    case Val_GNU_MIPS_ABI_FP_DOUBLE:
++      printf (_("Hard float (double precision)\n"));
++      break;
++    case Val_GNU_MIPS_ABI_FP_SINGLE:
++      printf (_("Hard float (single precision)\n"));
++      break;
++    case Val_GNU_MIPS_ABI_FP_SOFT:
++      printf (_("Soft float\n"));
++      break;
++    case Val_GNU_MIPS_ABI_FP_OLD_64:
++      printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
++      break;
++    case Val_GNU_MIPS_ABI_FP_XX:
++      printf (_("Hard float (32-bit CPU, Any FPU)\n"));
++      break;
++    case Val_GNU_MIPS_ABI_FP_64:
++      printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
++      break;
++    case Val_GNU_MIPS_ABI_FP_64A:
++      printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
++      break;
++    case Val_GNU_MIPS_ABI_FP_NAN2008:
++      printf (_("NaN 2008 compatibility\n"));
++      break;
++    default:
++      printf ("??? (%d)\n", val);
++      break;
++    }
++}
++
++static unsigned char *
++display_mips_gnu_attribute (unsigned char * p,
++			    unsigned int tag,
++			    const unsigned char * const end)
++{
++  if (tag == Tag_GNU_MIPS_ABI_FP)
++    {
++      unsigned int val;
++
++      printf ("  Tag_GNU_MIPS_ABI_FP: ");
++      READ_ULEB (val, p, end);
++      print_mips_fp_abi_value (val);
++      return p;
++   }
++
++  if (tag == Tag_GNU_MIPS_ABI_MSA)
++    {
++      unsigned int val;
++
++      printf ("  Tag_GNU_MIPS_ABI_MSA: ");
++      READ_ULEB (val, p, end);
++
++      switch (val)
++	{
++	case Val_GNU_MIPS_ABI_MSA_ANY:
++	  printf (_("Any MSA or not\n"));
++	  break;
++	case Val_GNU_MIPS_ABI_MSA_128:
++	  printf (_("128-bit MSA\n"));
++	  break;
++	default:
++	  printf ("??? (%d)\n", val);
++	  break;
++	}
++      return p;
++    }
++
++  return display_tag_value (tag & 1, p, end);
++}
++
++static unsigned char *
++display_tic6x_attribute (unsigned char * p,
++			 const unsigned char * const end)
++{
++  unsigned int tag;
++  unsigned int val;
++
++  READ_ULEB (tag, p, end);
++
++  switch (tag)
++    {
++    case Tag_ISA:
++      printf ("  Tag_ISA: ");
++      READ_ULEB (val, p, end);
++
++      switch (val)
++	{
++	case C6XABI_Tag_ISA_none:
++	  printf (_("None\n"));
++	  break;
++	case C6XABI_Tag_ISA_C62X:
++	  printf ("C62x\n");
++	  break;
++	case C6XABI_Tag_ISA_C67X:
++	  printf ("C67x\n");
++	  break;
++	case C6XABI_Tag_ISA_C67XP:
++	  printf ("C67x+\n");
++	  break;
++	case C6XABI_Tag_ISA_C64X:
++	  printf ("C64x\n");
++	  break;
++	case C6XABI_Tag_ISA_C64XP:
++	  printf ("C64x+\n");
++	  break;
++	case C6XABI_Tag_ISA_C674X:
++	  printf ("C674x\n");
++	  break;
++	default:
++	  printf ("??? (%d)\n", val);
++	  break;
++	}
++      return p;
++
++    case Tag_ABI_wchar_t:
++      printf ("  Tag_ABI_wchar_t: ");
++      READ_ULEB (val, p, end);
++      switch (val)
++	{
++	case 0:
++	  printf (_("Not used\n"));
++	  break;
++	case 1:
++	  printf (_("2 bytes\n"));
++	  break;
++	case 2:
++	  printf (_("4 bytes\n"));
++	  break;
++	default:
++	  printf ("??? (%d)\n", val);
++	  break;
++	}
++      return p;
++
++    case Tag_ABI_stack_align_needed:
++      printf ("  Tag_ABI_stack_align_needed: ");
++      READ_ULEB (val, p, end);
++      switch (val)
++	{
++	case 0:
++	  printf (_("8-byte\n"));
++	  break;
++	case 1:
++	  printf (_("16-byte\n"));
++	  break;
++	default:
++	  printf ("??? (%d)\n", val);
++	  break;
++	}
++      return p;
++
++    case Tag_ABI_stack_align_preserved:
++      READ_ULEB (val, p, end);
++      printf ("  Tag_ABI_stack_align_preserved: ");
++      switch (val)
++	{
++	case 0:
++	  printf (_("8-byte\n"));
++	  break;
++	case 1:
++	  printf (_("16-byte\n"));
++	  break;
++	default:
++	  printf ("??? (%d)\n", val);
++	  break;
++	}
++      return p;
++
++    case Tag_ABI_DSBT:
++      READ_ULEB (val, p, end);
++      printf ("  Tag_ABI_DSBT: ");
++      switch (val)
++	{
++	case 0:
++	  printf (_("DSBT addressing not used\n"));
++	  break;
++	case 1:
++	  printf (_("DSBT addressing used\n"));
++	  break;
++	default:
++	  printf ("??? (%d)\n", val);
++	  break;
++	}
++      return p;
++
++    case Tag_ABI_PID:
++      READ_ULEB (val, p, end);
++      printf ("  Tag_ABI_PID: ");
++      switch (val)
++	{
++	case 0:
++	  printf (_("Data addressing position-dependent\n"));
++	  break;
++	case 1:
++	  printf (_("Data addressing position-independent, GOT near DP\n"));
++	  break;
++	case 2:
++	  printf (_("Data addressing position-independent, GOT far from DP\n"));
++	  break;
++	default:
++	  printf ("??? (%d)\n", val);
++	  break;
++	}
++      return p;
++
++    case Tag_ABI_PIC:
++      READ_ULEB (val, p, end);
++      printf ("  Tag_ABI_PIC: ");
++      switch (val)
++	{
++	case 0:
++	  printf (_("Code addressing position-dependent\n"));
++	  break;
++	case 1:
++	  printf (_("Code addressing position-independent\n"));
++	  break;
++	default:
++	  printf ("??? (%d)\n", val);
++	  break;
++	}
++      return p;
++
++    case Tag_ABI_array_object_alignment:
++      READ_ULEB (val, p, end);
++      printf ("  Tag_ABI_array_object_alignment: ");
++      switch (val)
++	{
++	case 0:
++	  printf (_("8-byte\n"));
++	  break;
++	case 1:
++	  printf (_("4-byte\n"));
++	  break;
++	case 2:
++	  printf (_("16-byte\n"));
++	  break;
++	default:
++	  printf ("??? (%d)\n", val);
++	  break;
++	}
++      return p;
++
++    case Tag_ABI_array_object_align_expected:
++      READ_ULEB (val, p, end);
++      printf ("  Tag_ABI_array_object_align_expected: ");
++      switch (val)
++	{
++	case 0:
++	  printf (_("8-byte\n"));
++	  break;
++	case 1:
++	  printf (_("4-byte\n"));
++	  break;
++	case 2:
++	  printf (_("16-byte\n"));
++	  break;
++	default:
++	  printf ("??? (%d)\n", val);
++	  break;
++	}
++      return p;
++
++    case Tag_ABI_compatibility:
++      {
++	READ_ULEB (val, p, end);
++	printf ("  Tag_ABI_compatibility: ");
++	printf (_("flag = %d, vendor = "), val);
++	if (p < end - 1)
++	  {
++	    size_t maxlen = (end - p) - 1;
++
++	    print_symbol ((int) maxlen, (const char *) p);
++	    p += strnlen ((char *) p, maxlen) + 1;
++	  }
++	else
++	  {
++	    printf (_("<corrupt>"));
++	    p = (unsigned char *) end;
++	  }
++	putchar ('\n');
++	return p;
++      }
++
++    case Tag_ABI_conformance:
++      {
++	printf ("  Tag_ABI_conformance: \"");
++	if (p < end - 1)
++	  {
++	    size_t maxlen = (end - p) - 1;
++
++	    print_symbol ((int) maxlen, (const char *) p);
++	    p += strnlen ((char *) p, maxlen) + 1;
++	  }
++	else
++	  {
++	    printf (_("<corrupt>"));
++	    p = (unsigned char *) end;
++	  }
++	printf ("\"\n");
++	return p;
++      }
++    }
++
++  return display_tag_value (tag, p, end);
++}
++
++static void
++display_raw_attribute (unsigned char * p, unsigned char const * const end)
++{
++  unsigned long addr = 0;
++  size_t bytes = end - p;
++
++  assert (end >= p);
++  while (bytes)
++    {
++      int j;
++      int k;
++      int lbytes = (bytes > 16 ? 16 : bytes);
++
++      printf ("  0x%8.8lx ", addr);
++
++      for (j = 0; j < 16; j++)
++	{
++	  if (j < lbytes)
++	    printf ("%2.2x", p[j]);
++	  else
++	    printf ("  ");
++
++	  if ((j & 3) == 3)
++	    printf (" ");
++	}
++
++      for (j = 0; j < lbytes; j++)
++	{
++	  k = p[j];
++	  if (k >= ' ' && k < 0x7f)
++	    printf ("%c", k);
++	  else
++	    printf (".");
++	}
++
++      putchar ('\n');
++
++      p  += lbytes;
++      bytes -= lbytes;
++      addr += lbytes;
++    }
++
++  putchar ('\n');
++}
++
++static unsigned char *
++display_msp430_attribute (unsigned char * p,
++			   const unsigned char * const end)
++{
++  unsigned int val;
++  unsigned int tag;
++
++  READ_ULEB (tag, p, end);
++
++  switch (tag)
++    {
++    case OFBA_MSPABI_Tag_ISA:
++      printf ("  Tag_ISA: ");
++      READ_ULEB (val, p, end);
++      switch (val)
++	{
++	case 0: printf (_("None\n")); break;
++	case 1: printf (_("MSP430\n")); break;
++	case 2: printf (_("MSP430X\n")); break;
++	default: printf ("??? (%d)\n", val); break;
++	}
++      break;
++
++    case OFBA_MSPABI_Tag_Code_Model:
++      printf ("  Tag_Code_Model: ");
++      READ_ULEB (val, p, end);
++      switch (val)
++	{
++	case 0: printf (_("None\n")); break;
++	case 1: printf (_("Small\n")); break;
++	case 2: printf (_("Large\n")); break;
++	default: printf ("??? (%d)\n", val); break;
++	}
++      break;
++
++    case OFBA_MSPABI_Tag_Data_Model:
++      printf ("  Tag_Data_Model: ");
++      READ_ULEB (val, p, end);
++      switch (val)
++	{
++	case 0: printf (_("None\n")); break;
++	case 1: printf (_("Small\n")); break;
++	case 2: printf (_("Large\n")); break;
++	case 3: printf (_("Restricted Large\n")); break;
++	default: printf ("??? (%d)\n", val); break;
++	}
++      break;
++
++    default:
++      printf (_("  <unknown tag %d>: "), tag);
++
++      if (tag & 1)
++	{
++	  putchar ('"');
++	  if (p < end - 1)
++	    {
++	      size_t maxlen = (end - p) - 1;
++
++	      print_symbol ((int) maxlen, (const char *) p);
++	      p += strnlen ((char *) p, maxlen) + 1;
++	    }
++	  else
++	    {
++	      printf (_("<corrupt>"));
++	      p = (unsigned char *) end;
++	    }
++	  printf ("\"\n");
++	}
++      else
++	{
++	  READ_ULEB (val, p, end);
++	  printf ("%d (0x%x)\n", val, val);
++	}
++      break;
++   }
++
++  assert (p <= end);
++  return p;
++}
++
++static unsigned char *
++display_msp430_gnu_attribute (unsigned char * p,
++			      unsigned int tag,
++			      const unsigned char * const end)
++{
++  if (tag == Tag_GNU_MSP430_Data_Region)
++    {
++      unsigned int val;
++
++      printf ("  Tag_GNU_MSP430_Data_Region: ");
++      READ_ULEB (val, p, end);
++
++      switch (val)
++	{
++	case Val_GNU_MSP430_Data_Region_Any:
++	  printf (_("Any Region\n"));
++	  break;
++	case Val_GNU_MSP430_Data_Region_Lower:
++	  printf (_("Lower Region Only\n"));
++	  break;
++	default:
++	  printf ("??? (%u)\n", val);
++	}
++      return p;
++    }
++  return display_tag_value (tag & 1, p, end);
++}
++
++struct riscv_attr_tag_t {
++  const char *name;
++  unsigned int tag;
++};
++
++static struct riscv_attr_tag_t riscv_attr_tag[] =
++{
++#define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
++  T(arch),
++  T(priv_spec),
++  T(priv_spec_minor),
++  T(priv_spec_revision),
++  T(unaligned_access),
++  T(stack_align),
++#undef T
++};
++
++static unsigned char *
++display_riscv_attribute (unsigned char *p,
++			 const unsigned char * const end)
++{
++  unsigned int val;
++  unsigned int tag;
++  struct riscv_attr_tag_t *attr = NULL;
++  unsigned i;
++
++  READ_ULEB (tag, p, end);
++
++  /* Find the name of attribute. */
++  for (i = 0; i < ARRAY_SIZE (riscv_attr_tag); i++)
++    {
++      if (riscv_attr_tag[i].tag == tag)
++	{
++	  attr = &riscv_attr_tag[i];
++	  break;
++	}
++    }
++
++  if (attr)
++    printf ("  %s: ", attr->name);
++  else
++    return display_tag_value (tag, p, end);
++
++  switch (tag)
++    {
++    case Tag_RISCV_priv_spec:
++    case Tag_RISCV_priv_spec_minor:
++    case Tag_RISCV_priv_spec_revision:
++      READ_ULEB (val, p, end);
++      printf (_("%u\n"), val);
++      break;
++    case Tag_RISCV_unaligned_access:
++      READ_ULEB (val, p, end);
++      switch (val)
++	{
++	case 0:
++	  printf (_("No unaligned access\n"));
++	  break;
++	case 1:
++	  printf (_("Unaligned access\n"));
++	  break;
++	}
++      break;
++    case Tag_RISCV_stack_align:
++      READ_ULEB (val, p, end);
++      printf (_("%u-bytes\n"), val);
++      break;
++    case Tag_RISCV_arch:
++      p = display_tag_value (-1, p, end);
++      break;
++    default:
++      return display_tag_value (tag, p, end);
++    }
++
++  return p;
++}
++
++static unsigned char *
++display_csky_attribute (unsigned char * p,
++			const unsigned char * const end)
++{
++  unsigned int tag;
++  unsigned int val;
++  READ_ULEB (tag, p, end);
++
++  if (tag >= Tag_CSKY_MAX)
++    {
++      return display_tag_value (-1, p, end);
++    }
++
++  switch (tag)
++    {
++    case Tag_CSKY_ARCH_NAME:
++      printf ("  Tag_CSKY_ARCH_NAME:\t\t");
++      return display_tag_value (-1, p, end);
++    case Tag_CSKY_CPU_NAME:
++      printf ("  Tag_CSKY_CPU_NAME:\t\t");
++      return display_tag_value (-1, p, end);
++
++    case Tag_CSKY_ISA_FLAGS:
++      printf ("  Tag_CSKY_ISA_FLAGS:\t\t");
++      return display_tag_value (0, p, end);
++    case Tag_CSKY_ISA_EXT_FLAGS:
++      printf ("  Tag_CSKY_ISA_EXT_FLAGS:\t");
++      return display_tag_value (0, p, end);
++
++    case Tag_CSKY_DSP_VERSION:
++      printf ("  Tag_CSKY_DSP_VERSION:\t\t");
++      READ_ULEB (val, p, end);
++      if (val == VAL_CSKY_DSP_VERSION_EXTENSION)
++	printf ("DSP Extension\n");
++      else if (val == VAL_CSKY_DSP_VERSION_2)
++	printf ("DSP 2.0\n");
++      break;
++
++    case Tag_CSKY_VDSP_VERSION:
++      printf ("  Tag_CSKY_VDSP_VERSION:\t");
++      READ_ULEB (val, p, end);
++      printf ("VDSP Version %d\n", val);
++      break;
++
++    case Tag_CSKY_FPU_VERSION:
++      printf ("  Tag_CSKY_FPU_VERSION:\t\t");
++      READ_ULEB (val, p, end);
++      if (val == VAL_CSKY_FPU_VERSION_1)
++	printf ("ABIV1 FPU Version 1\n");
++      else if (val == VAL_CSKY_FPU_VERSION_2)
++	printf ("FPU Version 2\n");
++      break;
++
++    case Tag_CSKY_FPU_ABI:
++      printf ("  Tag_CSKY_FPU_ABI:\t\t");
++      READ_ULEB (val, p, end);
++      if (val == VAL_CSKY_FPU_ABI_HARD)
++	printf ("Hard\n");
++      else if (val == VAL_CSKY_FPU_ABI_SOFTFP)
++	printf ("SoftFP\n");
++      else if (val == VAL_CSKY_FPU_ABI_SOFT)
++	printf ("Soft\n");
++      break;
++    case Tag_CSKY_FPU_ROUNDING:
++      READ_ULEB (val, p, end);
++      if (val == 1) {
++	printf ("  Tag_CSKY_FPU_ROUNDING:\t");
++	printf ("Needed\n");
++      }
++      break;
++    case Tag_CSKY_FPU_DENORMAL:
++      READ_ULEB (val, p, end);
++      if (val == 1) {
++	printf ("  Tag_CSKY_FPU_DENORMAL:\t");
++	printf ("Needed\n");
++      }
++      break;
++    case Tag_CSKY_FPU_Exception:
++      READ_ULEB (val, p, end);
++      if (val == 1) {
++	printf ("  Tag_CSKY_FPU_Exception:\t");
++	printf ("Needed\n");
++      }
++      break;
++    case Tag_CSKY_FPU_NUMBER_MODULE:
++      printf ("  Tag_CSKY_FPU_NUMBER_MODULE:\t");
++      return display_tag_value (-1, p, end);
++    case Tag_CSKY_FPU_HARDFP:
++      printf ("  Tag_CSKY_FPU_HARDFP:\t\t");
++      READ_ULEB (val, p, end);
++      if (val & VAL_CSKY_FPU_HARDFP_HALF)
++	printf (" Half");
++      if (val & VAL_CSKY_FPU_HARDFP_SINGLE)
++	printf (" Single");
++      if (val & VAL_CSKY_FPU_HARDFP_DOUBLE)
++	printf (" Double");
++      printf ("\n");
++      break;
++    default:
++      return display_tag_value (tag, p, end);
++     }
++  return p;
++}
++
++static bool
++process_attributes (Filedata * filedata,
++		    const char * public_name,
++		    unsigned int proc_type,
++		    unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
++		    unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
++{
++  Elf_Internal_Shdr * sect;
++  unsigned i;
++  bool res = true;
++
++  /* Find the section header so that we get the size.  */
++  for (i = 0, sect = filedata->section_headers;
++       i < filedata->file_header.e_shnum;
++       i++, sect++)
++    {
++      unsigned char * contents;
++      unsigned char * p;
++
++      if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
++	continue;
++
++      contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
++                                             sect->sh_size, _("attributes"));
++      if (contents == NULL)
++	{
++	  res = false;
++	  continue;
++	}
++
++      p = contents;
++      /* The first character is the version of the attributes.
++	 Currently only version 1, (aka 'A') is recognised here.  */
++      if (*p != 'A')
++	{
++	  printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
++	  res = false;
++	}
++      else
++	{
++	  bfd_vma section_len;
++
++	  section_len = sect->sh_size - 1;
++	  p++;
++
++	  while (section_len > 0)
++	    {
++	      bfd_vma attr_len;
++	      unsigned int namelen;
++	      bool public_section;
++	      bool gnu_section;
++
++	      if (section_len <= 4)
++		{
++		  error (_("Tag section ends prematurely\n"));
++		  res = false;
++		  break;
++		}
++	      attr_len = byte_get (p, 4);
++	      p += 4;
++
++	      if (attr_len > section_len)
++		{
++		  error (_("Bad attribute length (%u > %u)\n"),
++			  (unsigned) attr_len, (unsigned) section_len);
++		  attr_len = section_len;
++		  res = false;
++		}
++	      /* PR 17531: file: 001-101425-0.004  */
++	      else if (attr_len < 5)
++		{
++		  error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
++		  res = false;
++		  break;
++		}
++
++	      section_len -= attr_len;
++	      attr_len -= 4;
++
++	      namelen = strnlen ((char *) p, attr_len) + 1;
++	      if (namelen == 0 || namelen >= attr_len)
++		{
++		  error (_("Corrupt attribute section name\n"));
++		  res = false;
++		  break;
++		}
++
++	      printf (_("Attribute Section: "));
++	      print_symbol (INT_MAX, (const char *) p);
++	      putchar ('\n');
++
++	      if (public_name && streq ((char *) p, public_name))
++		public_section = true;
++	      else
++		public_section = false;
++
++	      if (streq ((char *) p, "gnu"))
++		gnu_section = true;
++	      else
++		gnu_section = false;
++
++	      p += namelen;
++	      attr_len -= namelen;
++
++	      while (attr_len > 0 && p < contents + sect->sh_size)
++		{
++		  int tag;
++		  unsigned int val;
++		  bfd_vma size;
++		  unsigned char * end;
++
++		  /* PR binutils/17531: Safe handling of corrupt files.  */
++		  if (attr_len < 6)
++		    {
++		      error (_("Unused bytes at end of section\n"));
++		      res = false;
++		      section_len = 0;
++		      break;
++		    }
++
++		  tag = *(p++);
++		  size = byte_get (p, 4);
++		  if (size > attr_len)
++		    {
++		      error (_("Bad subsection length (%u > %u)\n"),
++			      (unsigned) size, (unsigned) attr_len);
++		      res = false;
++		      size = attr_len;
++		    }
++		  /* PR binutils/17531: Safe handling of corrupt files.  */
++		  if (size < 6)
++		    {
++		      error (_("Bad subsection length (%u < 6)\n"),
++			      (unsigned) size);
++		      res = false;
++		      section_len = 0;
++		      break;
++		    }
++
++		  attr_len -= size;
++		  end = p + size - 1;
++		  assert (end <= contents + sect->sh_size);
++		  p += 4;
++
++		  switch (tag)
++		    {
++		    case 1:
++		      printf (_("File Attributes\n"));
++		      break;
++		    case 2:
++		      printf (_("Section Attributes:"));
++		      goto do_numlist;
++		    case 3:
++		      printf (_("Symbol Attributes:"));
++		      /* Fall through.  */
++		    do_numlist:
++		      for (;;)
++			{
++			  READ_ULEB (val, p, end);
++			  if (val == 0)
++			    break;
++			  printf (" %d", val);
++			}
++		      printf ("\n");
++		      break;
++		    default:
++		      printf (_("Unknown tag: %d\n"), tag);
++		      public_section = false;
++		      break;
++		    }
++
++		  if (public_section && display_pub_attribute != NULL)
++		    {
++		      while (p < end)
++			p = display_pub_attribute (p, end);
++		      assert (p == end);
++		    }
++		  else if (gnu_section && display_proc_gnu_attribute != NULL)
++		    {
++		      while (p < end)
++			p = display_gnu_attribute (p,
++						   display_proc_gnu_attribute,
++						   end);
++		      assert (p == end);
++		    }
++		  else if (p < end)
++		    {
++		      printf (_("  Unknown attribute:\n"));
++		      display_raw_attribute (p, end);
++		      p = end;
++		    }
++		  else
++		    attr_len = 0;
++		}
++	    }
++	}
++
++      free (contents);
++    }
++
++  return res;
++}
++
++/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
++   Print the Address, Access and Initial fields of an entry at VMA ADDR
++   and return the VMA of the next entry, or -1 if there was a problem.
++   Does not read from DATA_END or beyond.  */
++
++static bfd_vma
++print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
++		      unsigned char * data_end)
++{
++  printf ("  ");
++  print_vma (addr, LONG_HEX);
++  printf (" ");
++  if (addr < pltgot + 0xfff0)
++    printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
++  else
++    printf ("%10s", "");
++  printf (" ");
++  if (data == NULL)
++    printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
++  else
++    {
++      bfd_vma entry;
++      unsigned char * from = data + addr - pltgot;
++
++      if (from + (is_32bit_elf ? 4 : 8) > data_end)
++	{
++	  warn (_("MIPS GOT entry extends beyond the end of available data\n"));
++	  printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
++	  return (bfd_vma) -1;
++	}
++      else
++	{
++	  entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
++	  print_vma (entry, LONG_HEX);
++	}
++    }
++  return addr + (is_32bit_elf ? 4 : 8);
++}
++
++/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
++   PLTGOT.  Print the Address and Initial fields of an entry at VMA
++   ADDR and return the VMA of the next entry.  */
++
++static bfd_vma
++print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
++{
++  printf ("  ");
++  print_vma (addr, LONG_HEX);
++  printf (" ");
++  if (data == NULL)
++    printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
++  else
++    {
++      bfd_vma entry;
++
++      entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
++      print_vma (entry, LONG_HEX);
++    }
++  return addr + (is_32bit_elf ? 4 : 8);
++}
++
++static void
++print_mips_ases (unsigned int mask)
++{
++  if (mask & AFL_ASE_DSP)
++    fputs ("\n\tDSP ASE", stdout);
++  if (mask & AFL_ASE_DSPR2)
++    fputs ("\n\tDSP R2 ASE", stdout);
++  if (mask & AFL_ASE_DSPR3)
++    fputs ("\n\tDSP R3 ASE", stdout);
++  if (mask & AFL_ASE_EVA)
++    fputs ("\n\tEnhanced VA Scheme", stdout);
++  if (mask & AFL_ASE_MCU)
++    fputs ("\n\tMCU (MicroController) ASE", stdout);
++  if (mask & AFL_ASE_MDMX)
++    fputs ("\n\tMDMX ASE", stdout);
++  if (mask & AFL_ASE_MIPS3D)
++    fputs ("\n\tMIPS-3D ASE", stdout);
++  if (mask & AFL_ASE_MT)
++    fputs ("\n\tMT ASE", stdout);
++  if (mask & AFL_ASE_SMARTMIPS)
++    fputs ("\n\tSmartMIPS ASE", stdout);
++  if (mask & AFL_ASE_VIRT)
++    fputs ("\n\tVZ ASE", stdout);
++  if (mask & AFL_ASE_MSA)
++    fputs ("\n\tMSA ASE", stdout);
++  if (mask & AFL_ASE_MIPS16)
++    fputs ("\n\tMIPS16 ASE", stdout);
++  if (mask & AFL_ASE_MICROMIPS)
++    fputs ("\n\tMICROMIPS ASE", stdout);
++  if (mask & AFL_ASE_XPA)
++    fputs ("\n\tXPA ASE", stdout);
++  if (mask & AFL_ASE_MIPS16E2)
++    fputs ("\n\tMIPS16e2 ASE", stdout);
++  if (mask & AFL_ASE_CRC)
++    fputs ("\n\tCRC ASE", stdout);
++  if (mask & AFL_ASE_GINV)
++    fputs ("\n\tGINV ASE", stdout);
++  if (mask & AFL_ASE_LOONGSON_MMI)
++    fputs ("\n\tLoongson MMI ASE", stdout);
++  if (mask & AFL_ASE_LOONGSON_CAM)
++    fputs ("\n\tLoongson CAM ASE", stdout);
++  if (mask & AFL_ASE_LOONGSON_EXT)
++    fputs ("\n\tLoongson EXT ASE", stdout);
++  if (mask & AFL_ASE_LOONGSON_EXT2)
++    fputs ("\n\tLoongson EXT2 ASE", stdout);
++  if (mask == 0)
++    fprintf (stdout, "\n\t%s", _("None"));
++  else if ((mask & ~AFL_ASE_MASK) != 0)
++    fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
++}
++
++static void
++print_mips_isa_ext (unsigned int isa_ext)
++{
++  switch (isa_ext)
++    {
++    case 0:
++      fputs (_("None"), stdout);
++      break;
++    case AFL_EXT_XLR:
++      fputs ("RMI XLR", stdout);
++      break;
++    case AFL_EXT_OCTEON3:
++      fputs ("Cavium Networks Octeon3", stdout);
++      break;
++    case AFL_EXT_OCTEON2:
++      fputs ("Cavium Networks Octeon2", stdout);
++      break;
++    case AFL_EXT_OCTEONP:
++      fputs ("Cavium Networks OcteonP", stdout);
++      break;
++    case AFL_EXT_OCTEON:
++      fputs ("Cavium Networks Octeon", stdout);
++      break;
++    case AFL_EXT_5900:
++      fputs ("Toshiba R5900", stdout);
++      break;
++    case AFL_EXT_4650:
++      fputs ("MIPS R4650", stdout);
++      break;
++    case AFL_EXT_4010:
++      fputs ("LSI R4010", stdout);
++      break;
++    case AFL_EXT_4100:
++      fputs ("NEC VR4100", stdout);
++      break;
++    case AFL_EXT_3900:
++      fputs ("Toshiba R3900", stdout);
++      break;
++    case AFL_EXT_10000:
++      fputs ("MIPS R10000", stdout);
++      break;
++    case AFL_EXT_SB1:
++      fputs ("Broadcom SB-1", stdout);
++      break;
++    case AFL_EXT_4111:
++      fputs ("NEC VR4111/VR4181", stdout);
++      break;
++    case AFL_EXT_4120:
++      fputs ("NEC VR4120", stdout);
++      break;
++    case AFL_EXT_5400:
++      fputs ("NEC VR5400", stdout);
++      break;
++    case AFL_EXT_5500:
++      fputs ("NEC VR5500", stdout);
++      break;
++    case AFL_EXT_LOONGSON_2E:
++      fputs ("ST Microelectronics Loongson 2E", stdout);
++      break;
++    case AFL_EXT_LOONGSON_2F:
++      fputs ("ST Microelectronics Loongson 2F", stdout);
++      break;
++    case AFL_EXT_INTERAPTIV_MR2:
++      fputs ("Imagination interAptiv MR2", stdout);
++      break;
++    default:
++      fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
++    }
++}
++
++static signed int
++get_mips_reg_size (int reg_size)
++{
++  return (reg_size == AFL_REG_NONE) ? 0
++	 : (reg_size == AFL_REG_32) ? 32
++	 : (reg_size == AFL_REG_64) ? 64
++	 : (reg_size == AFL_REG_128) ? 128
++	 : -1;
++}
++
++static bool
++process_mips_specific (Filedata * filedata)
++{
++  Elf_Internal_Dyn * entry;
++  Elf_Internal_Shdr *sect = NULL;
++  size_t liblist_offset = 0;
++  size_t liblistno = 0;
++  size_t conflictsno = 0;
++  size_t options_offset = 0;
++  size_t conflicts_offset = 0;
++  size_t pltrelsz = 0;
++  size_t pltrel = 0;
++  bfd_vma pltgot = 0;
++  bfd_vma mips_pltgot = 0;
++  bfd_vma jmprel = 0;
++  bfd_vma local_gotno = 0;
++  bfd_vma gotsym = 0;
++  bfd_vma symtabno = 0;
++  bool res = true;
++
++  if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
++			    display_mips_gnu_attribute))
++    res = false;
++
++  sect = find_section (filedata, ".MIPS.abiflags");
++
++  if (sect != NULL)
++    {
++      Elf_External_ABIFlags_v0 *abiflags_ext;
++      Elf_Internal_ABIFlags_v0 abiflags_in;
++
++      if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
++	{
++	  error (_("Corrupt MIPS ABI Flags section.\n"));
++	  res = false;
++	}
++      else
++	{
++	  abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
++				   sect->sh_size, _("MIPS ABI Flags section"));
++	  if (abiflags_ext)
++	    {
++	      abiflags_in.version = BYTE_GET (abiflags_ext->version);
++	      abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
++	      abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
++	      abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
++	      abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
++	      abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
++	      abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
++	      abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
++	      abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
++	      abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
++	      abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
++
++	      printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
++	      printf ("\nISA: MIPS%d", abiflags_in.isa_level);
++	      if (abiflags_in.isa_rev > 1)
++		printf ("r%d", abiflags_in.isa_rev);
++	      printf ("\nGPR size: %d",
++		      get_mips_reg_size (abiflags_in.gpr_size));
++	      printf ("\nCPR1 size: %d",
++		      get_mips_reg_size (abiflags_in.cpr1_size));
++	      printf ("\nCPR2 size: %d",
++		      get_mips_reg_size (abiflags_in.cpr2_size));
++	      fputs ("\nFP ABI: ", stdout);
++	      print_mips_fp_abi_value (abiflags_in.fp_abi);
++	      fputs ("ISA Extension: ", stdout);
++	      print_mips_isa_ext (abiflags_in.isa_ext);
++	      fputs ("\nASEs:", stdout);
++	      print_mips_ases (abiflags_in.ases);
++	      printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
++	      printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
++	      fputc ('\n', stdout);
++	      free (abiflags_ext);
++	    }
++	}
++    }
++
++  /* We have a lot of special sections.  Thanks SGI!  */
++  if (filedata->dynamic_section == NULL)
++    {
++      /* No dynamic information available.  See if there is static GOT.  */
++      sect = find_section (filedata, ".got");
++      if (sect != NULL)
++	{
++	  unsigned char *data_end;
++	  unsigned char *data;
++	  bfd_vma ent, end;
++	  int addr_size;
++
++	  pltgot = sect->sh_addr;
++
++	  ent = pltgot;
++	  addr_size = (is_32bit_elf ? 4 : 8);
++	  end = pltgot + sect->sh_size;
++
++	  data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
++					     end - pltgot, 1,
++					     _("Global Offset Table data"));
++	  /* PR 12855: Null data is handled gracefully throughout.  */
++	  data_end = data + (end - pltgot);
++
++	  printf (_("\nStatic GOT:\n"));
++	  printf (_(" Canonical gp value: "));
++	  print_vma (ent + 0x7ff0, LONG_HEX);
++	  printf ("\n\n");
++
++	  /* In a dynamic binary GOT[0] is reserved for the dynamic
++	     loader to store the lazy resolver pointer, however in
++	     a static binary it may well have been omitted and GOT
++	     reduced to a table of addresses.
++	     PR 21344: Check for the entry being fully available
++	     before fetching it.  */
++	  if (data
++	      && data + ent - pltgot + addr_size <= data_end
++	      && byte_get (data + ent - pltgot, addr_size) == 0)
++	    {
++	      printf (_(" Reserved entries:\n"));
++	      printf (_("  %*s %10s %*s\n"),
++		      addr_size * 2, _("Address"), _("Access"),
++		      addr_size * 2, _("Value"));
++	      ent = print_mips_got_entry (data, pltgot, ent, data_end);
++	      printf ("\n");
++	      if (ent == (bfd_vma) -1)
++		goto sgot_print_fail;
++
++	      /* Check for the MSB of GOT[1] being set, identifying a
++		 GNU object.  This entry will be used by some runtime
++		 loaders, to store the module pointer.  Otherwise this
++		 is an ordinary local entry.
++		 PR 21344: Check for the entry being fully available
++		 before fetching it.  */
++	      if (data
++		  && data + ent - pltgot + addr_size <= data_end
++		  && (byte_get (data + ent - pltgot, addr_size)
++		      >> (addr_size * 8 - 1)) != 0)
++		{
++		  ent = print_mips_got_entry (data, pltgot, ent, data_end);
++		  printf ("\n");
++		  if (ent == (bfd_vma) -1)
++		    goto sgot_print_fail;
++		}
++	      printf ("\n");
++	    }
++
++	  if (data != NULL && ent < end)
++	    {
++	      printf (_(" Local entries:\n"));
++	      printf ("  %*s %10s %*s\n",
++		      addr_size * 2, _("Address"), _("Access"),
++		      addr_size * 2, _("Value"));
++	      while (ent < end)
++		{
++		  ent = print_mips_got_entry (data, pltgot, ent, data_end);
++		  printf ("\n");
++		  if (ent == (bfd_vma) -1)
++		    goto sgot_print_fail;
++		}
++	      printf ("\n");
++	    }
++
++	sgot_print_fail:
++	  free (data);
++	}
++      return res;
++    }
++
++  for (entry = filedata->dynamic_section;
++       /* PR 17531 file: 012-50589-0.004.  */
++       (entry < filedata->dynamic_section + filedata->dynamic_nent
++	&& entry->d_tag != DT_NULL);
++       ++entry)
++    switch (entry->d_tag)
++      {
++      case DT_MIPS_LIBLIST:
++	liblist_offset
++	  = offset_from_vma (filedata, entry->d_un.d_val,
++			     liblistno * sizeof (Elf32_External_Lib));
++	break;
++      case DT_MIPS_LIBLISTNO:
++	liblistno = entry->d_un.d_val;
++	break;
++      case DT_MIPS_OPTIONS:
++	options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
++	break;
++      case DT_MIPS_CONFLICT:
++	conflicts_offset
++	  = offset_from_vma (filedata, entry->d_un.d_val,
++			     conflictsno * sizeof (Elf32_External_Conflict));
++	break;
++      case DT_MIPS_CONFLICTNO:
++	conflictsno = entry->d_un.d_val;
++	break;
++      case DT_PLTGOT:
++	pltgot = entry->d_un.d_ptr;
++	break;
++      case DT_MIPS_LOCAL_GOTNO:
++	local_gotno = entry->d_un.d_val;
++	break;
++      case DT_MIPS_GOTSYM:
++	gotsym = entry->d_un.d_val;
++	break;
++      case DT_MIPS_SYMTABNO:
++	symtabno = entry->d_un.d_val;
++	break;
++      case DT_MIPS_PLTGOT:
++	mips_pltgot = entry->d_un.d_ptr;
++	break;
++      case DT_PLTREL:
++	pltrel = entry->d_un.d_val;
++	break;
++      case DT_PLTRELSZ:
++	pltrelsz = entry->d_un.d_val;
++	break;
++      case DT_JMPREL:
++	jmprel = entry->d_un.d_ptr;
++	break;
++      default:
++	break;
++      }
++
++  if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
++    {
++      Elf32_External_Lib * elib;
++      size_t cnt;
++
++      elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
++					      sizeof (Elf32_External_Lib),
++					      liblistno,
++					      _("liblist section data"));
++      if (elib)
++	{
++	  printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
++			    "\nSection '.liblist' contains %lu entries:\n",
++			    (unsigned long) liblistno),
++		  (unsigned long) liblistno);
++	  fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
++		 stdout);
++
++	  for (cnt = 0; cnt < liblistno; ++cnt)
++	    {
++	      Elf32_Lib liblist;
++	      time_t atime;
++	      char timebuf[128];
++	      struct tm * tmp;
++
++	      liblist.l_name = BYTE_GET (elib[cnt].l_name);
++	      atime = BYTE_GET (elib[cnt].l_time_stamp);
++	      liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
++	      liblist.l_version = BYTE_GET (elib[cnt].l_version);
++	      liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
++
++	      tmp = gmtime (&atime);
++	      snprintf (timebuf, sizeof (timebuf),
++			"%04u-%02u-%02uT%02u:%02u:%02u",
++			tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
++			tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
++
++	      printf ("%3lu: ", (unsigned long) cnt);
++	      if (VALID_DYNAMIC_NAME (filedata, liblist.l_name))
++		print_symbol (20, GET_DYNAMIC_NAME (filedata, liblist.l_name));
++	      else
++		printf (_("<corrupt: %9ld>"), liblist.l_name);
++	      printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
++		      liblist.l_version);
++
++	      if (liblist.l_flags == 0)
++		puts (_(" NONE"));
++	      else
++		{
++		  static const struct
++		  {
++		    const char * name;
++		    int bit;
++		  }
++		  l_flags_vals[] =
++		  {
++		    { " EXACT_MATCH", LL_EXACT_MATCH },
++		    { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
++		    { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
++		    { " EXPORTS", LL_EXPORTS },
++		    { " DELAY_LOAD", LL_DELAY_LOAD },
++		    { " DELTA", LL_DELTA }
++		  };
++		  int flags = liblist.l_flags;
++		  size_t fcnt;
++
++		  for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
++		    if ((flags & l_flags_vals[fcnt].bit) != 0)
++		      {
++			fputs (l_flags_vals[fcnt].name, stdout);
++			flags ^= l_flags_vals[fcnt].bit;
++		      }
++		  if (flags != 0)
++		    printf (" %#x", (unsigned int) flags);
++
++		  puts ("");
++		}
++	    }
++
++	  free (elib);
++	}
++      else
++	res = false;
++    }
++
++  if (options_offset != 0)
++    {
++      Elf_External_Options * eopt;
++      size_t offset;
++      int cnt;
++      sect = filedata->section_headers;
++
++      /* Find the section header so that we get the size.  */
++      sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
++      /* PR 17533 file: 012-277276-0.004.  */
++      if (sect == NULL)
++	{
++	  error (_("No MIPS_OPTIONS header found\n"));
++	  return false;
++	}
++      /* PR 24243  */
++      if (sect->sh_size < sizeof (* eopt))
++	{
++	  error (_("The MIPS options section is too small.\n"));
++	  return false;
++	}
++
++      eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
++                                                sect->sh_size, _("options"));
++      if (eopt)
++	{
++	  Elf_Internal_Options option;
++
++	  offset = cnt = 0;
++	  while (offset <= sect->sh_size - sizeof (* eopt))
++	    {
++	      Elf_External_Options * eoption;
++	      unsigned int optsize;
++
++	      eoption = (Elf_External_Options *) ((char *) eopt + offset);
++
++	      optsize = BYTE_GET (eoption->size);
++
++	      /* PR 17531: file: ffa0fa3b.  */
++	      if (optsize < sizeof (* eopt)
++		  || optsize > sect->sh_size - offset)
++		{
++		  error (_("Invalid size (%u) for MIPS option\n"),
++			 optsize);
++		  free (eopt);
++		  return false;
++		}
++	      offset += optsize;
++	      ++cnt;
++	    }
++
++	  printf (ngettext ("\nSection '%s' contains %d entry:\n",
++			    "\nSection '%s' contains %d entries:\n",
++			    cnt),
++		  printable_section_name (filedata, sect), cnt);
++
++	  offset = 0;
++	  while (cnt-- > 0)
++	    {
++	      size_t len;
++	      Elf_External_Options * eoption;
++
++	      eoption = (Elf_External_Options *) ((char *) eopt + offset);
++
++	      option.kind = BYTE_GET (eoption->kind);
++	      option.size = BYTE_GET (eoption->size);
++	      option.section = BYTE_GET (eoption->section);
++	      option.info = BYTE_GET (eoption->info);
++
++	      switch (option.kind)
++		{
++		case ODK_NULL:
++		  /* This shouldn't happen.  */
++		  printf (" NULL       %" PRId16 " %" PRIx32,
++			  option.section, option.info);
++		  break;
++
++		case ODK_REGINFO:
++		  printf (" REGINFO    ");
++		  if (filedata->file_header.e_machine == EM_MIPS)
++		    {
++		      Elf32_External_RegInfo * ereg;
++		      Elf32_RegInfo reginfo;
++
++		      /* 32bit form.  */
++		      if (option.size < (sizeof (Elf_External_Options)
++					 + sizeof (Elf32_External_RegInfo)))
++			{
++			  printf (_("<corrupt>\n"));
++			  error (_("Truncated MIPS REGINFO option\n"));
++			  cnt = 0;
++			  break;
++			}
++
++		      ereg = (Elf32_External_RegInfo *) (eoption + 1);
++
++		      reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
++		      reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
++		      reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
++		      reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
++		      reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
++		      reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
++
++		      printf ("GPR %08" PRIx32 "  GP 0x%" PRIx32 "\n",
++			      reginfo.ri_gprmask, reginfo.ri_gp_value);
++		      printf ("          "
++			      "  CPR0 %08" PRIx32 "  CPR1 %08" PRIx32
++			      "  CPR2 %08" PRIx32 "  CPR3 %08" PRIx32 "\n",
++			      reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
++			      reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
++		    }
++		  else
++		    {
++		      /* 64 bit form.  */
++		      Elf64_External_RegInfo * ereg;
++		      Elf64_Internal_RegInfo reginfo;
++
++		      if (option.size < (sizeof (Elf_External_Options)
++					 + sizeof (Elf64_External_RegInfo)))
++			{
++			  printf (_("<corrupt>\n"));
++			  error (_("Truncated MIPS REGINFO option\n"));
++			  cnt = 0;
++			  break;
++			}
++
++		      ereg = (Elf64_External_RegInfo *) (eoption + 1);
++		      reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
++		      reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
++		      reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
++		      reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
++		      reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
++		      reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
++
++		      printf ("GPR %08" PRIx32 "  GP 0x%" PRIx64 "\n",
++			      reginfo.ri_gprmask, reginfo.ri_gp_value);
++		      printf ("          "
++			      "  CPR0 %08" PRIx32 "  CPR1 %08" PRIx32
++			      "  CPR2 %08" PRIx32 "  CPR3 %08" PRIx32 "\n",
++			      reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
++			      reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
++		    }
++		  offset += option.size;
++		  continue;
++
++		case ODK_EXCEPTIONS:
++		  fputs (" EXCEPTIONS fpe_min(", stdout);
++		  process_mips_fpe_exception (option.info & OEX_FPU_MIN);
++		  fputs (") fpe_max(", stdout);
++		  process_mips_fpe_exception ((option.info & OEX_FPU_MAX) >> 8);
++		  fputs (")", stdout);
++
++		  if (option.info & OEX_PAGE0)
++		    fputs (" PAGE0", stdout);
++		  if (option.info & OEX_SMM)
++		    fputs (" SMM", stdout);
++		  if (option.info & OEX_FPDBUG)
++		    fputs (" FPDBUG", stdout);
++		  if (option.info & OEX_DISMISS)
++		    fputs (" DISMISS", stdout);
++		  break;
++
++		case ODK_PAD:
++		  fputs (" PAD       ", stdout);
++		  if (option.info & OPAD_PREFIX)
++		    fputs (" PREFIX", stdout);
++		  if (option.info & OPAD_POSTFIX)
++		    fputs (" POSTFIX", stdout);
++		  if (option.info & OPAD_SYMBOL)
++		    fputs (" SYMBOL", stdout);
++		  break;
++
++		case ODK_HWPATCH:
++		  fputs (" HWPATCH   ", stdout);
++		  if (option.info & OHW_R4KEOP)
++		    fputs (" R4KEOP", stdout);
++		  if (option.info & OHW_R8KPFETCH)
++		    fputs (" R8KPFETCH", stdout);
++		  if (option.info & OHW_R5KEOP)
++		    fputs (" R5KEOP", stdout);
++		  if (option.info & OHW_R5KCVTL)
++		    fputs (" R5KCVTL", stdout);
++		  break;
++
++		case ODK_FILL:
++		  fputs (" FILL       ", stdout);
++		  /* XXX Print content of info word?  */
++		  break;
++
++		case ODK_TAGS:
++		  fputs (" TAGS       ", stdout);
++		  /* XXX Print content of info word?  */
++		  break;
++
++		case ODK_HWAND:
++		  fputs (" HWAND     ", stdout);
++		  if (option.info & OHWA0_R4KEOP_CHECKED)
++		    fputs (" R4KEOP_CHECKED", stdout);
++		  if (option.info & OHWA0_R4KEOP_CLEAN)
++		    fputs (" R4KEOP_CLEAN", stdout);
++		  break;
++
++		case ODK_HWOR:
++		  fputs (" HWOR      ", stdout);
++		  if (option.info & OHWA0_R4KEOP_CHECKED)
++		    fputs (" R4KEOP_CHECKED", stdout);
++		  if (option.info & OHWA0_R4KEOP_CLEAN)
++		    fputs (" R4KEOP_CLEAN", stdout);
++		  break;
++
++		case ODK_GP_GROUP:
++		  printf (" GP_GROUP  %#06x  self-contained %#06x",
++			  option.info & OGP_GROUP,
++			  (option.info & OGP_SELF) >> 16);
++		  break;
++
++		case ODK_IDENT:
++		  printf (" IDENT     %#06x  self-contained %#06x",
++			  option.info & OGP_GROUP,
++			  (option.info & OGP_SELF) >> 16);
++		  break;
++
++		default:
++		  /* This shouldn't happen.  */
++		  printf (" %3d ???     %" PRId16 " %" PRIx32,
++			  option.kind, option.section, option.info);
++		  break;
++		}
++
++	      len = sizeof (* eopt);
++	      while (len < option.size)
++		{
++		  unsigned char datum = *((unsigned char *) eoption + len);
++
++		  if (ISPRINT (datum))
++		    printf ("%c", datum);
++		  else
++		    printf ("\\%03o", datum);
++		  len ++;
++		}
++	      fputs ("\n", stdout);
++
++	      offset += option.size;
++	    }
++	  free (eopt);
++	}
++      else
++	res = false;
++    }
++
++  if (conflicts_offset != 0 && conflictsno != 0)
++    {
++      Elf32_Conflict * iconf;
++      size_t cnt;
++
++      if (filedata->dynamic_symbols == NULL)
++	{
++	  error (_("conflict list found without a dynamic symbol table\n"));
++	  return false;
++	}
++
++      /* PR 21345 - print a slightly more helpful error message
++	 if we are sure that the cmalloc will fail.  */
++      if (conflictsno > filedata->file_size / sizeof (* iconf))
++	{
++	  error (_("Overlarge number of conflicts detected: %lx\n"),
++		 (long) conflictsno);
++	  return false;
++	}
++
++      iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
++      if (iconf == NULL)
++	{
++	  error (_("Out of memory allocating space for dynamic conflicts\n"));
++	  return false;
++	}
++
++      if (is_32bit_elf)
++	{
++	  Elf32_External_Conflict * econf32;
++
++	  econf32 = (Elf32_External_Conflict *)
++	    get_data (NULL, filedata, conflicts_offset,
++		      sizeof (*econf32), conflictsno, _("conflict"));
++	  if (!econf32)
++	    {
++	      free (iconf);
++	      return false;
++	    }
++
++	  for (cnt = 0; cnt < conflictsno; ++cnt)
++	    iconf[cnt] = BYTE_GET (econf32[cnt]);
++
++	  free (econf32);
++	}
++      else
++	{
++	  Elf64_External_Conflict * econf64;
++
++	  econf64 = (Elf64_External_Conflict *)
++	    get_data (NULL, filedata, conflicts_offset,
++		      sizeof (*econf64), conflictsno, _("conflict"));
++	  if (!econf64)
++	    {
++	      free (iconf);
++	      return false;
++	    }
++
++	  for (cnt = 0; cnt < conflictsno; ++cnt)
++	    iconf[cnt] = BYTE_GET (econf64[cnt]);
++
++	  free (econf64);
++	}
++
++      printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
++			"\nSection '.conflict' contains %lu entries:\n",
++			(unsigned long) conflictsno),
++	      (unsigned long) conflictsno);
++      puts (_("  Num:    Index       Value  Name"));
++
++      for (cnt = 0; cnt < conflictsno; ++cnt)
++	{
++	  printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
++
++	  if (iconf[cnt] >= filedata->num_dynamic_syms)
++	    printf (_("<corrupt symbol index>"));
++	  else
++	    {
++	      Elf_Internal_Sym * psym;
++
++	      psym = & filedata->dynamic_symbols[iconf[cnt]];
++	      print_vma (psym->st_value, FULL_HEX);
++	      putchar (' ');
++	      if (VALID_DYNAMIC_NAME (filedata, psym->st_name))
++		print_symbol (25, GET_DYNAMIC_NAME (filedata, psym->st_name));
++	      else
++		printf (_("<corrupt: %14ld>"), psym->st_name);
++	    }
++	  putchar ('\n');
++	}
++
++      free (iconf);
++    }
++
++  if (pltgot != 0 && local_gotno != 0)
++    {
++      bfd_vma ent, local_end, global_end;
++      size_t i, offset;
++      unsigned char * data;
++      unsigned char * data_end;
++      int addr_size;
++
++      ent = pltgot;
++      addr_size = (is_32bit_elf ? 4 : 8);
++      local_end = pltgot + local_gotno * addr_size;
++
++      /* PR binutils/17533 file: 012-111227-0.004  */
++      if (symtabno < gotsym)
++	{
++	  error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
++		 (unsigned long) gotsym, (unsigned long) symtabno);
++	  return false;
++	}
++
++      global_end = local_end + (symtabno - gotsym) * addr_size;
++      /* PR 17531: file: 54c91a34.  */
++      if (global_end < local_end)
++	{
++	  error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
++	  return false;
++	}
++
++      offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
++      data = (unsigned char *) get_data (NULL, filedata, offset,
++                                         global_end - pltgot, 1,
++					 _("Global Offset Table data"));
++      /* PR 12855: Null data is handled gracefully throughout.  */
++      data_end = data + (global_end - pltgot);
++
++      printf (_("\nPrimary GOT:\n"));
++      printf (_(" Canonical gp value: "));
++      print_vma (pltgot + 0x7ff0, LONG_HEX);
++      printf ("\n\n");
++
++      printf (_(" Reserved entries:\n"));
++      printf (_("  %*s %10s %*s Purpose\n"),
++	      addr_size * 2, _("Address"), _("Access"),
++	      addr_size * 2, _("Initial"));
++      ent = print_mips_got_entry (data, pltgot, ent, data_end);
++      printf (_(" Lazy resolver\n"));
++      if (ent == (bfd_vma) -1)
++	goto got_print_fail;
++
++      /* Check for the MSB of GOT[1] being set, denoting a GNU object.
++	 This entry will be used by some runtime loaders, to store the
++	 module pointer.  Otherwise this is an ordinary local entry.
++	 PR 21344: Check for the entry being fully available before
++	 fetching it.  */
++      if (data
++	  && data + ent - pltgot + addr_size <= data_end
++	  && (byte_get (data + ent - pltgot, addr_size)
++	      >> (addr_size * 8 - 1)) != 0)
++	{
++	  ent = print_mips_got_entry (data, pltgot, ent, data_end);
++	  printf (_(" Module pointer (GNU extension)\n"));
++	  if (ent == (bfd_vma) -1)
++	    goto got_print_fail;
++	}
++      printf ("\n");
++
++      if (data != NULL && ent < local_end)
++	{
++	  printf (_(" Local entries:\n"));
++	  printf ("  %*s %10s %*s\n",
++		  addr_size * 2, _("Address"), _("Access"),
++		  addr_size * 2, _("Initial"));
++	  while (ent < local_end)
++	    {
++	      ent = print_mips_got_entry (data, pltgot, ent, data_end);
++	      printf ("\n");
++	      if (ent == (bfd_vma) -1)
++		goto got_print_fail;
++	    }
++	  printf ("\n");
++	}
++
++      if (data != NULL && gotsym < symtabno)
++	{
++	  int sym_width;
++
++	  printf (_(" Global entries:\n"));
++	  printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
++		  addr_size * 2, _("Address"),
++		  _("Access"),
++		  addr_size * 2, _("Initial"),
++		  addr_size * 2, _("Sym.Val."),
++		  _("Type"),
++		  /* Note for translators: "Ndx" = abbreviated form of "Index".  */
++		  _("Ndx"), _("Name"));
++
++	  sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
++
++	  for (i = gotsym; i < symtabno; i++)
++	    {
++	      ent = print_mips_got_entry (data, pltgot, ent, data_end);
++	      printf (" ");
++
++	      if (filedata->dynamic_symbols == NULL)
++		printf (_("<no dynamic symbols>"));
++	      else if (i < filedata->num_dynamic_syms)
++		{
++		  Elf_Internal_Sym * psym = filedata->dynamic_symbols + i;
++
++		  print_vma (psym->st_value, LONG_HEX);
++		  printf (" %-7s %3s ",
++			  get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
++			  get_symbol_index_type (filedata, psym->st_shndx));
++
++		  if (VALID_DYNAMIC_NAME (filedata, psym->st_name))
++		    print_symbol (sym_width,
++				  GET_DYNAMIC_NAME (filedata, psym->st_name));
++		  else
++		    printf (_("<corrupt: %14ld>"), psym->st_name);
++		}
++	      else
++		printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
++			(unsigned long) i);
++
++	      printf ("\n");
++	      if (ent == (bfd_vma) -1)
++		break;
++	    }
++	  printf ("\n");
++	}
++
++    got_print_fail:
++      free (data);
++    }
++
++  if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
++    {
++      bfd_vma ent, end;
++      size_t offset, rel_offset;
++      unsigned long count, i;
++      unsigned char * data;
++      int addr_size, sym_width;
++      Elf_Internal_Rela * rels;
++
++      rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
++      if (pltrel == DT_RELA)
++	{
++	  if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
++	    return false;
++	}
++      else
++	{
++	  if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
++	    return false;
++	}
++
++      ent = mips_pltgot;
++      addr_size = (is_32bit_elf ? 4 : 8);
++      end = mips_pltgot + (2 + count) * addr_size;
++
++      offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
++      data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
++                                         1, _("Procedure Linkage Table data"));
++      if (data == NULL)
++	{
++	  free (rels);
++	  return false;
++	}
++
++      printf ("\nPLT GOT:\n\n");
++      printf (_(" Reserved entries:\n"));
++      printf (_("  %*s %*s Purpose\n"),
++	      addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
++      ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
++      printf (_(" PLT lazy resolver\n"));
++      ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
++      printf (_(" Module pointer\n"));
++      printf ("\n");
++
++      printf (_(" Entries:\n"));
++      printf ("  %*s %*s %*s %-7s %3s %s\n",
++	      addr_size * 2, _("Address"),
++	      addr_size * 2, _("Initial"),
++	      addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
++      sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
++      for (i = 0; i < count; i++)
++	{
++	  unsigned long idx = get_reloc_symindex (rels[i].r_info);
++
++	  ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
++	  printf (" ");
++
++	  if (idx >= filedata->num_dynamic_syms)
++	    printf (_("<corrupt symbol index: %lu>"), idx);
++	  else
++	    {
++	      Elf_Internal_Sym * psym = filedata->dynamic_symbols + idx;
++
++	      print_vma (psym->st_value, LONG_HEX);
++	      printf (" %-7s %3s ",
++		      get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
++		      get_symbol_index_type (filedata, psym->st_shndx));
++	      if (VALID_DYNAMIC_NAME (filedata, psym->st_name))
++		print_symbol (sym_width,
++			      GET_DYNAMIC_NAME (filedata, psym->st_name));
++	      else
++		printf (_("<corrupt: %14ld>"), psym->st_name);
++	    }
++	  printf ("\n");
++	}
++      printf ("\n");
++
++      free (data);
++      free (rels);
++    }
++
++  return res;
++}
++
++static bool
++process_nds32_specific (Filedata * filedata)
++{
++  Elf_Internal_Shdr *sect = NULL;
++
++  sect = find_section (filedata, ".nds32_e_flags");
++  if (sect != NULL && sect->sh_size >= 4)
++    {
++      unsigned char *buf;
++      unsigned int flag;
++
++      printf ("\nNDS32 elf flags section:\n");
++      buf = get_data (NULL, filedata, sect->sh_offset, 1, 4,
++		      _("NDS32 elf flags section"));
++
++      if (buf == NULL)
++	return false;
++
++      flag = byte_get (buf, 4);
++      free (buf);
++      switch (flag & 0x3)
++	{
++	case 0:
++	  printf ("(VEC_SIZE):\tNo entry.\n");
++	  break;
++	case 1:
++	  printf ("(VEC_SIZE):\t4 bytes\n");
++	  break;
++	case 2:
++	  printf ("(VEC_SIZE):\t16 bytes\n");
++	  break;
++	case 3:
++	  printf ("(VEC_SIZE):\treserved\n");
++	  break;
++	}
++    }
++
++  return true;
++}
++
++static bool
++process_gnu_liblist (Filedata * filedata)
++{
++  Elf_Internal_Shdr * section;
++  Elf_Internal_Shdr * string_sec;
++  Elf32_External_Lib * elib;
++  char * strtab;
++  size_t strtab_size;
++  size_t cnt;
++  unsigned long num_liblist;
++  unsigned i;
++  bool res = true;
++
++  if (! do_arch)
++    return true;
++
++  for (i = 0, section = filedata->section_headers;
++       i < filedata->file_header.e_shnum;
++       i++, section++)
++    {
++      switch (section->sh_type)
++	{
++	case SHT_GNU_LIBLIST:
++	  if (section->sh_link >= filedata->file_header.e_shnum)
++	    break;
++
++	  elib = (Elf32_External_Lib *)
++              get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
++                        _("liblist section data"));
++
++	  if (elib == NULL)
++	    {
++	      res = false;
++	      break;
++	    }
++
++	  string_sec = filedata->section_headers + section->sh_link;
++	  strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
++                                      string_sec->sh_size,
++                                      _("liblist string table"));
++	  if (strtab == NULL
++	      || section->sh_entsize != sizeof (Elf32_External_Lib))
++	    {
++	      free (elib);
++	      free (strtab);
++	      res = false;
++	      break;
++	    }
++	  strtab_size = string_sec->sh_size;
++
++	  num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
++	  printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
++			    "\nLibrary list section '%s' contains %lu entries:\n",
++			    num_liblist),
++		  printable_section_name (filedata, section),
++		  num_liblist);
++
++	  puts (_("     Library              Time Stamp          Checksum   Version Flags"));
++
++	  for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
++	       ++cnt)
++	    {
++	      Elf32_Lib liblist;
++	      time_t atime;
++	      char timebuf[128];
++	      struct tm * tmp;
++
++	      liblist.l_name = BYTE_GET (elib[cnt].l_name);
++	      atime = BYTE_GET (elib[cnt].l_time_stamp);
++	      liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
++	      liblist.l_version = BYTE_GET (elib[cnt].l_version);
++	      liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
++
++	      tmp = gmtime (&atime);
++	      snprintf (timebuf, sizeof (timebuf),
++			"%04u-%02u-%02uT%02u:%02u:%02u",
++			tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
++			tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
++
++	      printf ("%3lu: ", (unsigned long) cnt);
++	      if (do_wide)
++		printf ("%-20s", liblist.l_name < strtab_size
++			? strtab + liblist.l_name : _("<corrupt>"));
++	      else
++		printf ("%-20.20s", liblist.l_name < strtab_size
++			? strtab + liblist.l_name : _("<corrupt>"));
++	      printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
++		      liblist.l_version, liblist.l_flags);
++	    }
++
++	  free (elib);
++	  free (strtab);
++	}
++    }
++
++  return res;
++}
++
++static const char *
++get_note_type (Filedata * filedata, unsigned e_type)
++{
++  static char buff[64];
++
++  if (filedata->file_header.e_type == ET_CORE)
++    switch (e_type)
++      {
++      case NT_AUXV:
++	return _("NT_AUXV (auxiliary vector)");
++      case NT_PRSTATUS:
++	return _("NT_PRSTATUS (prstatus structure)");
++      case NT_FPREGSET:
++	return _("NT_FPREGSET (floating point registers)");
++      case NT_PRPSINFO:
++	return _("NT_PRPSINFO (prpsinfo structure)");
++      case NT_TASKSTRUCT:
++	return _("NT_TASKSTRUCT (task structure)");
++      case NT_GDB_TDESC:
++        return _("NT_GDB_TDESC (GDB XML target description)");
++      case NT_PRXFPREG:
++	return _("NT_PRXFPREG (user_xfpregs structure)");
++      case NT_PPC_VMX:
++	return _("NT_PPC_VMX (ppc Altivec registers)");
++      case NT_PPC_VSX:
++	return _("NT_PPC_VSX (ppc VSX registers)");
++      case NT_PPC_TAR:
++	return _("NT_PPC_TAR (ppc TAR register)");
++      case NT_PPC_PPR:
++	return _("NT_PPC_PPR (ppc PPR register)");
++      case NT_PPC_DSCR:
++	return _("NT_PPC_DSCR (ppc DSCR register)");
++      case NT_PPC_EBB:
++	return _("NT_PPC_EBB (ppc EBB registers)");
++      case NT_PPC_PMU:
++	return _("NT_PPC_PMU (ppc PMU registers)");
++      case NT_PPC_TM_CGPR:
++	return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
++      case NT_PPC_TM_CFPR:
++	return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
++      case NT_PPC_TM_CVMX:
++	return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
++      case NT_PPC_TM_CVSX:
++	return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
++      case NT_PPC_TM_SPR:
++	return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
++      case NT_PPC_TM_CTAR:
++	return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
++      case NT_PPC_TM_CPPR:
++	return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
++      case NT_PPC_TM_CDSCR:
++	return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
++      case NT_386_TLS:
++	return _("NT_386_TLS (x86 TLS information)");
++      case NT_386_IOPERM:
++	return _("NT_386_IOPERM (x86 I/O permissions)");
++      case NT_X86_XSTATE:
++	return _("NT_X86_XSTATE (x86 XSAVE extended state)");
++      case NT_X86_CET:
++	return _("NT_X86_CET (x86 CET state)");
++      case NT_S390_HIGH_GPRS:
++	return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
++      case NT_S390_TIMER:
++	return _("NT_S390_TIMER (s390 timer register)");
++      case NT_S390_TODCMP:
++	return _("NT_S390_TODCMP (s390 TOD comparator register)");
++      case NT_S390_TODPREG:
++	return _("NT_S390_TODPREG (s390 TOD programmable register)");
++      case NT_S390_CTRS:
++	return _("NT_S390_CTRS (s390 control registers)");
++      case NT_S390_PREFIX:
++	return _("NT_S390_PREFIX (s390 prefix register)");
++      case NT_S390_LAST_BREAK:
++	return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
++      case NT_S390_SYSTEM_CALL:
++	return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
++      case NT_S390_TDB:
++	return _("NT_S390_TDB (s390 transaction diagnostic block)");
++      case NT_S390_VXRS_LOW:
++	return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
++      case NT_S390_VXRS_HIGH:
++	return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
++      case NT_S390_GS_CB:
++	return _("NT_S390_GS_CB (s390 guarded-storage registers)");
++      case NT_S390_GS_BC:
++	return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
++      case NT_ARM_VFP:
++	return _("NT_ARM_VFP (arm VFP registers)");
++      case NT_ARM_TLS:
++	return _("NT_ARM_TLS (AArch TLS registers)");
++      case NT_ARM_HW_BREAK:
++	return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
++      case NT_ARM_HW_WATCH:
++	return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
++      case NT_ARM_SVE:
++	return _("NT_ARM_SVE (AArch SVE registers)");
++      case NT_ARM_PAC_MASK:
++	return _("NT_ARM_PAC_MASK (AArch pointer authentication code masks)");
++      case NT_ARM_TAGGED_ADDR_CTRL:
++	return _("NT_ARM_TAGGED_ADDR_CTRL (AArch tagged address control)");
++      case NT_ARC_V2:
++	return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
++      case NT_RISCV_CSR:
++	return _("NT_RISCV_CSR (RISC-V control and status registers)");
++      case NT_PSTATUS:
++	return _("NT_PSTATUS (pstatus structure)");
++      case NT_FPREGS:
++	return _("NT_FPREGS (floating point registers)");
++      case NT_PSINFO:
++	return _("NT_PSINFO (psinfo structure)");
++      case NT_LWPSTATUS:
++	return _("NT_LWPSTATUS (lwpstatus_t structure)");
++      case NT_LWPSINFO:
++	return _("NT_LWPSINFO (lwpsinfo_t structure)");
++      case NT_WIN32PSTATUS:
++	return _("NT_WIN32PSTATUS (win32_pstatus structure)");
++      case NT_SIGINFO:
++	return _("NT_SIGINFO (siginfo_t data)");
++      case NT_FILE:
++	return _("NT_FILE (mapped files)");
++      case NT_MEMTAG:
++	return _("NT_MEMTAG (memory tags)");
++      default:
++	break;
++      }
++  else
++    switch (e_type)
++      {
++      case NT_VERSION:
++	return _("NT_VERSION (version)");
++      case NT_ARCH:
++	return _("NT_ARCH (architecture)");
++      case NT_GNU_BUILD_ATTRIBUTE_OPEN:
++	return _("OPEN");
++      case NT_GNU_BUILD_ATTRIBUTE_FUNC:
++	return _("func");
++      case NT_GO_BUILDID:
++	return _("GO BUILDID");
++      default:
++	break;
++      }
++
++  snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
++  return buff;
++}
++
++static bool
++print_core_note (Elf_Internal_Note *pnote)
++{
++  unsigned int addr_size = is_32bit_elf ? 4 : 8;
++  bfd_vma count, page_size;
++  unsigned char *descdata, *filenames, *descend;
++
++  if (pnote->type != NT_FILE)
++    {
++      if (do_wide)
++	printf ("\n");
++      return true;
++    }
++
++#ifndef BFD64
++  if (!is_32bit_elf)
++    {
++      printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
++      /* Still "successful".  */
++      return true;
++    }
++#endif
++
++  if (pnote->descsz < 2 * addr_size)
++    {
++      error (_("    Malformed note - too short for header\n"));
++      return false;
++    }
++
++  descdata = (unsigned char *) pnote->descdata;
++  descend = descdata + pnote->descsz;
++
++  if (descdata[pnote->descsz - 1] != '\0')
++    {
++      error (_("    Malformed note - does not end with \\0\n"));
++      return false;
++    }
++
++  count = byte_get (descdata, addr_size);
++  descdata += addr_size;
++
++  page_size = byte_get (descdata, addr_size);
++  descdata += addr_size;
++
++  if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
++      || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
++    {
++      error (_("    Malformed note - too short for supplied file count\n"));
++      return false;
++    }
++
++  printf (_("    Page size: "));
++  print_vma (page_size, DEC);
++  printf ("\n");
++
++  printf (_("    %*s%*s%*s\n"),
++	  (int) (2 + 2 * addr_size), _("Start"),
++	  (int) (4 + 2 * addr_size), _("End"),
++	  (int) (4 + 2 * addr_size), _("Page Offset"));
++  filenames = descdata + count * 3 * addr_size;
++  while (count-- > 0)
++    {
++      bfd_vma start, end, file_ofs;
++
++      if (filenames == descend)
++	{
++	  error (_("    Malformed note - filenames end too early\n"));
++	  return false;
++	}
++
++      start = byte_get (descdata, addr_size);
++      descdata += addr_size;
++      end = byte_get (descdata, addr_size);
++      descdata += addr_size;
++      file_ofs = byte_get (descdata, addr_size);
++      descdata += addr_size;
++
++      printf ("    ");
++      print_vma (start, FULL_HEX);
++      printf ("  ");
++      print_vma (end, FULL_HEX);
++      printf ("  ");
++      print_vma (file_ofs, FULL_HEX);
++      printf ("\n        %s\n", filenames);
++
++      filenames += 1 + strlen ((char *) filenames);
++    }
++
++  return true;
++}
++
++static const char *
++get_gnu_elf_note_type (unsigned e_type)
++{
++  /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
++  switch (e_type)
++    {
++    case NT_GNU_ABI_TAG:
++      return _("NT_GNU_ABI_TAG (ABI version tag)");
++    case NT_GNU_HWCAP:
++      return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
++    case NT_GNU_BUILD_ID:
++      return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
++    case NT_GNU_GOLD_VERSION:
++      return _("NT_GNU_GOLD_VERSION (gold version)");
++    case NT_GNU_PROPERTY_TYPE_0:
++      return _("NT_GNU_PROPERTY_TYPE_0");
++    case NT_GNU_BUILD_ATTRIBUTE_OPEN:
++      return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
++    case NT_GNU_BUILD_ATTRIBUTE_FUNC:
++      return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
++    default:
++      {
++	static char buff[64];
++
++	snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
++	return buff;
++      }
++    }
++}
++
++static void
++decode_x86_compat_isa (unsigned int bitmask)
++{
++  while (bitmask)
++    {
++      unsigned int bit = bitmask & (- bitmask);
++
++      bitmask &= ~ bit;
++      switch (bit)
++	{
++	case GNU_PROPERTY_X86_COMPAT_ISA_1_486:
++	  printf ("i486");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_ISA_1_586:
++	  printf ("586");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_ISA_1_686:
++	  printf ("686");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE:
++	  printf ("SSE");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2:
++	  printf ("SSE2");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3:
++	  printf ("SSE3");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3:
++	  printf ("SSSE3");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1:
++	  printf ("SSE4_1");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2:
++	  printf ("SSE4_2");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX:
++	  printf ("AVX");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2:
++	  printf ("AVX2");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F:
++	  printf ("AVX512F");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD:
++	  printf ("AVX512CD");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER:
++	  printf ("AVX512ER");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF:
++	  printf ("AVX512PF");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL:
++	  printf ("AVX512VL");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ:
++	  printf ("AVX512DQ");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW:
++	  printf ("AVX512BW");
++	  break;
++	default:
++	  printf (_("<unknown: %x>"), bit);
++	  break;
++	}
++      if (bitmask)
++	printf (", ");
++    }
++}
++
++static void
++decode_x86_compat_2_isa (unsigned int bitmask)
++{
++  if (!bitmask)
++    {
++      printf (_("<None>"));
++      return;
++    }
++
++  while (bitmask)
++    {
++      unsigned int bit = bitmask & (- bitmask);
++
++      bitmask &= ~ bit;
++      switch (bit)
++	{
++	case GNU_PROPERTY_X86_COMPAT_2_ISA_1_CMOV:
++	  printf ("CMOV");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE:
++	  printf ("SSE");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE2:
++	  printf ("SSE2");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE3:
++	  printf ("SSE3");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSSE3:
++	  printf ("SSSE3");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_1:
++	  printf ("SSE4_1");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_2:
++	  printf ("SSE4_2");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX:
++	  printf ("AVX");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX2:
++	  printf ("AVX2");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_2_ISA_1_FMA:
++	  printf ("FMA");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512F:
++	  printf ("AVX512F");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512CD:
++	  printf ("AVX512CD");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512ER:
++	  printf ("AVX512ER");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512PF:
++	  printf ("AVX512PF");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512VL:
++	  printf ("AVX512VL");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512DQ:
++	  printf ("AVX512DQ");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512BW:
++	  printf ("AVX512BW");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4FMAPS:
++	  printf ("AVX512_4FMAPS");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4VNNIW:
++	  printf ("AVX512_4VNNIW");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BITALG:
++	  printf ("AVX512_BITALG");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_IFMA:
++	  printf ("AVX512_IFMA");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI:
++	  printf ("AVX512_VBMI");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI2:
++	  printf ("AVX512_VBMI2");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VNNI:
++	  printf ("AVX512_VNNI");
++	  break;
++	case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BF16:
++	  printf ("AVX512_BF16");
++	  break;
++	default:
++	  printf (_("<unknown: %x>"), bit);
++	  break;
++	}
++      if (bitmask)
++	printf (", ");
++    }
++}
++
++static void
++decode_x86_isa (unsigned int bitmask)
++{
++  while (bitmask)
++    {
++      unsigned int bit = bitmask & (- bitmask);
++
++      bitmask &= ~ bit;
++      switch (bit)
++	{
++	case GNU_PROPERTY_X86_ISA_1_BASELINE:
++	  printf ("x86-64-baseline");
++	  break;
++	case GNU_PROPERTY_X86_ISA_1_V2:
++	  printf ("x86-64-v2");
++	  break;
++	case GNU_PROPERTY_X86_ISA_1_V3:
++	  printf ("x86-64-v3");
++	  break;
++	case GNU_PROPERTY_X86_ISA_1_V4:
++	  printf ("x86-64-v4");
++	  break;
++	default:
++	  printf (_("<unknown: %x>"), bit);
++	  break;
++	}
++      if (bitmask)
++	printf (", ");
++    }
++}
++
++static void
++decode_x86_feature_1 (unsigned int bitmask)
++{
++  if (!bitmask)
++    {
++      printf (_("<None>"));
++      return;
++    }
++
++  while (bitmask)
++    {
++      unsigned int bit = bitmask & (- bitmask);
++
++      bitmask &= ~ bit;
++      switch (bit)
++	{
++	case GNU_PROPERTY_X86_FEATURE_1_IBT:
++	  printf ("IBT");
++	  break;
++	case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
++	  printf ("SHSTK");
++	  break;
++	case GNU_PROPERTY_X86_FEATURE_1_LAM_U48:
++	  printf ("LAM_U48");
++	  break;
++	case GNU_PROPERTY_X86_FEATURE_1_LAM_U57:
++	  printf ("LAM_U57");
++	  break;
++	default:
++	  printf (_("<unknown: %x>"), bit);
++	  break;
++	}
++      if (bitmask)
++	printf (", ");
++    }
++}
++
++static void
++decode_x86_feature_2 (unsigned int bitmask)
++{
++  if (!bitmask)
++    {
++      printf (_("<None>"));
++      return;
++    }
++
++  while (bitmask)
++    {
++      unsigned int bit = bitmask & (- bitmask);
++
++      bitmask &= ~ bit;
++      switch (bit)
++	{
++	case GNU_PROPERTY_X86_FEATURE_2_X86:
++	  printf ("x86");
++	  break;
++	case GNU_PROPERTY_X86_FEATURE_2_X87:
++	  printf ("x87");
++	  break;
++	case GNU_PROPERTY_X86_FEATURE_2_MMX:
++	  printf ("MMX");
++	  break;
++	case GNU_PROPERTY_X86_FEATURE_2_XMM:
++	  printf ("XMM");
++	  break;
++	case GNU_PROPERTY_X86_FEATURE_2_YMM:
++	  printf ("YMM");
++	  break;
++	case GNU_PROPERTY_X86_FEATURE_2_ZMM:
++	  printf ("ZMM");
++	  break;
++	case GNU_PROPERTY_X86_FEATURE_2_TMM:
++	  printf ("TMM");
++	  break;
++	case GNU_PROPERTY_X86_FEATURE_2_MASK:
++	  printf ("MASK");
++	  break;
++	case GNU_PROPERTY_X86_FEATURE_2_FXSR:
++	  printf ("FXSR");
++	  break;
++	case GNU_PROPERTY_X86_FEATURE_2_XSAVE:
++	  printf ("XSAVE");
++	  break;
++	case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT:
++	  printf ("XSAVEOPT");
++	  break;
++	case GNU_PROPERTY_X86_FEATURE_2_XSAVEC:
++	  printf ("XSAVEC");
++	  break;
++	default:
++	  printf (_("<unknown: %x>"), bit);
++	  break;
++	}
++      if (bitmask)
++	printf (", ");
++    }
++}
++
++static void
++decode_aarch64_feature_1_and (unsigned int bitmask)
++{
++  while (bitmask)
++    {
++      unsigned int bit = bitmask & (- bitmask);
++
++      bitmask &= ~ bit;
++      switch (bit)
++	{
++	case GNU_PROPERTY_AARCH64_FEATURE_1_BTI:
++	  printf ("BTI");
++	  break;
++
++	case GNU_PROPERTY_AARCH64_FEATURE_1_PAC:
++	  printf ("PAC");
++	  break;
++
++	default:
++	  printf (_("<unknown: %x>"), bit);
++	  break;
++	}
++      if (bitmask)
++	printf (", ");
++    }
++}
++
++static void
++print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
++{
++  unsigned char * ptr = (unsigned char *) pnote->descdata;
++  unsigned char * ptr_end = ptr + pnote->descsz;
++  unsigned int    size = is_32bit_elf ? 4 : 8;
++
++  printf (_("      Properties: "));
++
++  if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
++    {
++      printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
++      return;
++    }
++
++  while (ptr < ptr_end)
++    {
++      unsigned int j;
++      unsigned int type;
++      unsigned int datasz;
++
++      if ((size_t) (ptr_end - ptr) < 8)
++	{
++	  printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
++	  break;
++	}
++
++      type = byte_get (ptr, 4);
++      datasz = byte_get (ptr + 4, 4);
++
++      ptr += 8;
++
++      if (datasz > (size_t) (ptr_end - ptr))
++	{
++	  printf (_("<corrupt type (%#x) datasz: %#x>\n"),
++		  type, datasz);
++	  break;
++	}
++
++      if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
++	{
++	  if (filedata->file_header.e_machine == EM_X86_64
++	      || filedata->file_header.e_machine == EM_IAMCU
++	      || filedata->file_header.e_machine == EM_386)
++	    {
++	      unsigned int bitmask;
++
++	      if (datasz == 4)
++		bitmask = byte_get (ptr, 4);
++	      else
++		bitmask = 0;
++
++	      switch (type)
++		{
++		case GNU_PROPERTY_X86_ISA_1_USED:
++		  if (datasz != 4)
++		    printf (_("x86 ISA used: <corrupt length: %#x> "),
++			    datasz);
++		  else
++		    {
++		      printf ("x86 ISA used: ");
++		      decode_x86_isa (bitmask);
++		    }
++		  goto next;
++
++		case GNU_PROPERTY_X86_ISA_1_NEEDED:
++		  if (datasz != 4)
++		    printf (_("x86 ISA needed: <corrupt length: %#x> "),
++			    datasz);
++		  else
++		    {
++		      printf ("x86 ISA needed: ");
++		      decode_x86_isa (bitmask);
++		    }
++		  goto next;
++
++		case GNU_PROPERTY_X86_FEATURE_1_AND:
++		  if (datasz != 4)
++		    printf (_("x86 feature: <corrupt length: %#x> "),
++			    datasz);
++		  else
++		    {
++		      printf ("x86 feature: ");
++		      decode_x86_feature_1 (bitmask);
++		    }
++		  goto next;
++
++		case GNU_PROPERTY_X86_FEATURE_2_USED:
++		  if (datasz != 4)
++		    printf (_("x86 feature used: <corrupt length: %#x> "),
++			    datasz);
++		  else
++		    {
++		      printf ("x86 feature used: ");
++		      decode_x86_feature_2 (bitmask);
++		    }
++		  goto next;
++
++		case GNU_PROPERTY_X86_FEATURE_2_NEEDED:
++		  if (datasz != 4)
++		    printf (_("x86 feature needed: <corrupt length: %#x> "), datasz);
++		  else
++		    {
++		      printf ("x86 feature needed: ");
++		      decode_x86_feature_2 (bitmask);
++		    }
++		  goto next;
++
++		case GNU_PROPERTY_X86_COMPAT_ISA_1_USED:
++		  if (datasz != 4)
++		    printf (_("x86 ISA used: <corrupt length: %#x> "),
++			    datasz);
++		  else
++		    {
++		      printf ("x86 ISA used: ");
++		      decode_x86_compat_isa (bitmask);
++		    }
++		  goto next;
++
++		case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED:
++		  if (datasz != 4)
++		    printf (_("x86 ISA needed: <corrupt length: %#x> "),
++			    datasz);
++		  else
++		    {
++		      printf ("x86 ISA needed: ");
++		      decode_x86_compat_isa (bitmask);
++		    }
++		  goto next;
++
++		case GNU_PROPERTY_X86_COMPAT_2_ISA_1_USED:
++		  if (datasz != 4)
++		    printf (_("x86 ISA used: <corrupt length: %#x> "),
++			    datasz);
++		  else
++		    {
++		      printf ("x86 ISA used: ");
++		      decode_x86_compat_2_isa (bitmask);
++		    }
++		  goto next;
++
++		case GNU_PROPERTY_X86_COMPAT_2_ISA_1_NEEDED:
++		  if (datasz != 4)
++		    printf (_("x86 ISA needed: <corrupt length: %#x> "),
++			    datasz);
++		  else
++		    {
++		      printf ("x86 ISA needed: ");
++		      decode_x86_compat_2_isa (bitmask);
++		    }
++		  goto next;
++
++		default:
++		  break;
++		}
++	    }
++	  else if (filedata->file_header.e_machine == EM_AARCH64)
++	    {
++	      if (type == GNU_PROPERTY_AARCH64_FEATURE_1_AND)
++		{
++		  printf ("AArch64 feature: ");
++		  if (datasz != 4)
++		    printf (_("<corrupt length: %#x> "), datasz);
++		  else
++		    decode_aarch64_feature_1_and (byte_get (ptr, 4));
++		  goto next;
++		}
++	    }
++	}
++      else
++	{
++	  switch (type)
++	    {
++	    case GNU_PROPERTY_STACK_SIZE:
++	      printf (_("stack size: "));
++	      if (datasz != size)
++		printf (_("<corrupt length: %#x> "), datasz);
++	      else
++		printf ("%#lx", (unsigned long) byte_get (ptr, size));
++	      goto next;
++
++	    case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
++	      printf ("no copy on protected ");
++	      if (datasz)
++		printf (_("<corrupt length: %#x> "), datasz);
++	      goto next;
++
++	    default:
++	      if ((type >= GNU_PROPERTY_UINT32_AND_LO
++		   && type <= GNU_PROPERTY_UINT32_AND_HI)
++		  || (type >= GNU_PROPERTY_UINT32_OR_LO
++		      && type <= GNU_PROPERTY_UINT32_OR_HI))
++		{
++		  if (type <= GNU_PROPERTY_UINT32_AND_HI)
++		    printf (_("UINT32_AND (%#x): "), type);
++		  else
++		    printf (_("UINT32_OR (%#x): "), type);
++		  if (datasz != 4)
++		    printf (_("<corrupt length: %#x> "), datasz);
++		  else
++		    printf ("%#x", (unsigned int) byte_get (ptr, 4));
++		  goto next;
++		}
++	      break;
++	    }
++	}
++
++      if (type < GNU_PROPERTY_LOPROC)
++	printf (_("<unknown type %#x data: "), type);
++      else if (type < GNU_PROPERTY_LOUSER)
++	printf (_("<processor-specific type %#x data: "), type);
++      else
++	printf (_("<application-specific type %#x data: "), type);
++      for (j = 0; j < datasz; ++j)
++	printf ("%02x ", ptr[j] & 0xff);
++      printf (">");
++
++    next:
++      ptr += ((datasz + (size - 1)) & ~ (size - 1));
++      if (ptr == ptr_end)
++	break;
++
++      if (do_wide)
++	printf (", ");
++      else
++	printf ("\n\t");
++    }
++
++  printf ("\n");
++}
++
++static bool
++print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
++{
++  /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
++  switch (pnote->type)
++    {
++    case NT_GNU_BUILD_ID:
++      {
++	unsigned long i;
++
++	printf (_("    Build ID: "));
++	for (i = 0; i < pnote->descsz; ++i)
++	  printf ("%02x", pnote->descdata[i] & 0xff);
++	printf ("\n");
++      }
++      break;
++
++    case NT_GNU_ABI_TAG:
++      {
++	unsigned long os, major, minor, subminor;
++	const char *osname;
++
++	/* PR 17531: file: 030-599401-0.004.  */
++	if (pnote->descsz < 16)
++	  {
++	    printf (_("    <corrupt GNU_ABI_TAG>\n"));
++	    break;
++	  }
++
++	os = byte_get ((unsigned char *) pnote->descdata, 4);
++	major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
++	minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
++	subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
++
++	switch (os)
++	  {
++	  case GNU_ABI_TAG_LINUX:
++	    osname = "Linux";
++	    break;
++	  case GNU_ABI_TAG_HURD:
++	    osname = "Hurd";
++	    break;
++	  case GNU_ABI_TAG_SOLARIS:
++	    osname = "Solaris";
++	    break;
++	  case GNU_ABI_TAG_FREEBSD:
++	    osname = "FreeBSD";
++	    break;
++	  case GNU_ABI_TAG_NETBSD:
++	    osname = "NetBSD";
++	    break;
++	  case GNU_ABI_TAG_SYLLABLE:
++	    osname = "Syllable";
++	    break;
++	  case GNU_ABI_TAG_NACL:
++	    osname = "NaCl";
++	    break;
++	  default:
++	    osname = "Unknown";
++	    break;
++	  }
++
++	printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
++		major, minor, subminor);
++      }
++      break;
++
++    case NT_GNU_GOLD_VERSION:
++      {
++	unsigned long i;
++
++	printf (_("    Version: "));
++	for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
++	  printf ("%c", pnote->descdata[i]);
++	printf ("\n");
++      }
++      break;
++
++    case NT_GNU_HWCAP:
++      {
++	unsigned long num_entries, mask;
++
++	/* Hardware capabilities information.  Word 0 is the number of entries.
++	   Word 1 is a bitmask of enabled entries.  The rest of the descriptor
++	   is a series of entries, where each entry is a single byte followed
++	   by a nul terminated string.  The byte gives the bit number to test
++	   if enabled in the bitmask.  */
++	printf (_("      Hardware Capabilities: "));
++	if (pnote->descsz < 8)
++	  {
++	    error (_("<corrupt GNU_HWCAP>\n"));
++	    return false;
++	  }
++	num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
++	mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
++	printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
++	/* FIXME: Add code to display the entries... */
++      }
++      break;
++
++    case NT_GNU_PROPERTY_TYPE_0:
++      print_gnu_property_note (filedata, pnote);
++      break;
++
++    default:
++      /* Handle unrecognised types.  An error message should have already been
++	 created by get_gnu_elf_note_type(), so all that we need to do is to
++	 display the data.  */
++      {
++	unsigned long i;
++
++	printf (_("    Description data: "));
++	for (i = 0; i < pnote->descsz; ++i)
++	  printf ("%02x ", pnote->descdata[i] & 0xff);
++	printf ("\n");
++      }
++      break;
++    }
++
++  return true;
++}
++
++static const char *
++get_v850_elf_note_type (enum v850_notes n_type)
++{
++  static char buff[64];
++
++  switch (n_type)
++    {
++    case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
++    case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
++    case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
++    case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
++    case V850_NOTE_CACHE_INFO: return _("Use of cache");
++    case V850_NOTE_MMU_INFO:   return _("Use of MMU");
++    default:
++      snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
++      return buff;
++    }
++}
++
++static bool
++print_v850_note (Elf_Internal_Note * pnote)
++{
++  unsigned int val;
++
++  if (pnote->descsz != 4)
++    return false;
++
++  val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
++
++  if (val == 0)
++    {
++      printf (_("not set\n"));
++      return true;
++    }
++
++  switch (pnote->type)
++    {
++    case V850_NOTE_ALIGNMENT:
++      switch (val)
++	{
++	case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return true;
++	case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return true;
++	}
++      break;
++
++    case V850_NOTE_DATA_SIZE:
++      switch (val)
++	{
++	case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return true;
++	case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return true;
++	}
++      break;
++
++    case V850_NOTE_FPU_INFO:
++      switch (val)
++	{
++	case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return true;
++	case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return true;
++	}
++      break;
++
++    case V850_NOTE_MMU_INFO:
++    case V850_NOTE_CACHE_INFO:
++    case V850_NOTE_SIMD_INFO:
++      if (val == EF_RH850_SIMD)
++	{
++	  printf (_("yes\n"));
++	  return true;
++	}
++      break;
++
++    default:
++      /* An 'unknown note type' message will already have been displayed.  */
++      break;
++    }
++
++  printf (_("unknown value: %x\n"), val);
++  return false;
++}
++
++static bool
++process_netbsd_elf_note (Elf_Internal_Note * pnote)
++{
++  unsigned int version;
++
++  switch (pnote->type)
++    {
++    case NT_NETBSD_IDENT:
++      if (pnote->descsz < 1)
++	break;
++      version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
++      if ((version / 10000) % 100)
++	printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
++		version, version / 100000000, (version / 1000000) % 100,
++		(version / 10000) % 100 > 26 ? "Z" : "",
++		'A' + (version / 10000) % 26);
++      else
++	printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
++		version, version / 100000000, (version / 1000000) % 100,
++		(version / 100) % 100);
++      return true;
++
++    case NT_NETBSD_MARCH:
++      printf ("  NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
++	      pnote->descdata);
++      return true;
++
++    case NT_NETBSD_PAX:
++      if (pnote->descsz < 1)
++	break;
++      version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
++      printf ("  NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote->descsz,
++	      ((version & NT_NETBSD_PAX_MPROTECT) ? "+mprotect" : ""),
++	      ((version & NT_NETBSD_PAX_NOMPROTECT) ? "-mprotect" : ""),
++	      ((version & NT_NETBSD_PAX_GUARD) ? "+guard" : ""),
++	      ((version & NT_NETBSD_PAX_NOGUARD) ? "-guard" : ""),
++	      ((version & NT_NETBSD_PAX_ASLR) ? "+ASLR" : ""),
++	      ((version & NT_NETBSD_PAX_NOASLR) ? "-ASLR" : ""));
++      return true;
++    }
++
++  printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
++	  pnote->descsz, pnote->type);
++  return false;
++}
++
++static const char *
++get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
++{
++  switch (e_type)
++    {
++    case NT_FREEBSD_THRMISC:
++      return _("NT_THRMISC (thrmisc structure)");
++    case NT_FREEBSD_PROCSTAT_PROC:
++      return _("NT_PROCSTAT_PROC (proc data)");
++    case NT_FREEBSD_PROCSTAT_FILES:
++      return _("NT_PROCSTAT_FILES (files data)");
++    case NT_FREEBSD_PROCSTAT_VMMAP:
++      return _("NT_PROCSTAT_VMMAP (vmmap data)");
++    case NT_FREEBSD_PROCSTAT_GROUPS:
++      return _("NT_PROCSTAT_GROUPS (groups data)");
++    case NT_FREEBSD_PROCSTAT_UMASK:
++      return _("NT_PROCSTAT_UMASK (umask data)");
++    case NT_FREEBSD_PROCSTAT_RLIMIT:
++      return _("NT_PROCSTAT_RLIMIT (rlimit data)");
++    case NT_FREEBSD_PROCSTAT_OSREL:
++      return _("NT_PROCSTAT_OSREL (osreldate data)");
++    case NT_FREEBSD_PROCSTAT_PSSTRINGS:
++      return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
++    case NT_FREEBSD_PROCSTAT_AUXV:
++      return _("NT_PROCSTAT_AUXV (auxv data)");
++    case NT_FREEBSD_PTLWPINFO:
++      return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
++    }
++  return get_note_type (filedata, e_type);
++}
++
++static const char *
++get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
++{
++  static char buff[64];
++
++  switch (e_type)
++    {
++    case NT_NETBSDCORE_PROCINFO:
++      /* NetBSD core "procinfo" structure.  */
++      return _("NetBSD procinfo structure");
++
++    case NT_NETBSDCORE_AUXV:
++      return _("NetBSD ELF auxiliary vector data");
++
++    case NT_NETBSDCORE_LWPSTATUS:
++      return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
++
++    default:
++      /* As of Jan 2020 there are no other machine-independent notes
++	 defined for NetBSD core files.  If the note type is less
++	 than the start of the machine-dependent note types, we don't
++	 understand it.  */
++
++      if (e_type < NT_NETBSDCORE_FIRSTMACH)
++	{
++	  snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
++	  return buff;
++	}
++      break;
++    }
++
++  switch (filedata->file_header.e_machine)
++    {
++    /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
++       and PT_GETFPREGS == mach+2.  */
++
++    case EM_OLD_ALPHA:
++    case EM_ALPHA:
++    case EM_SPARC:
++    case EM_SPARC32PLUS:
++    case EM_SPARCV9:
++      switch (e_type)
++	{
++	case NT_NETBSDCORE_FIRSTMACH + 0:
++	  return _("PT_GETREGS (reg structure)");
++	case NT_NETBSDCORE_FIRSTMACH + 2:
++	  return _("PT_GETFPREGS (fpreg structure)");
++	default:
++	  break;
++	}
++      break;
++
++    /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
++       There's also old PT___GETREGS40 == mach + 1 for old reg
++       structure which lacks GBR.  */
++    case EM_SH:
++      switch (e_type)
++	{
++	case NT_NETBSDCORE_FIRSTMACH + 1:
++	  return _("PT___GETREGS40 (old reg structure)");
++	case NT_NETBSDCORE_FIRSTMACH + 3:
++	  return _("PT_GETREGS (reg structure)");
++	case NT_NETBSDCORE_FIRSTMACH + 5:
++	  return _("PT_GETFPREGS (fpreg structure)");
++	default:
++	  break;
++	}
++      break;
++
++    /* On all other arch's, PT_GETREGS == mach+1 and
++       PT_GETFPREGS == mach+3.  */
++    default:
++      switch (e_type)
++	{
++	case NT_NETBSDCORE_FIRSTMACH + 1:
++	  return _("PT_GETREGS (reg structure)");
++	case NT_NETBSDCORE_FIRSTMACH + 3:
++	  return _("PT_GETFPREGS (fpreg structure)");
++	default:
++	  break;
++	}
++    }
++
++  snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
++	    e_type - NT_NETBSDCORE_FIRSTMACH);
++  return buff;
++}
++
++static const char *
++get_stapsdt_note_type (unsigned e_type)
++{
++  static char buff[64];
++
++  switch (e_type)
++    {
++    case NT_STAPSDT:
++      return _("NT_STAPSDT (SystemTap probe descriptors)");
++
++    default:
++      break;
++    }
++
++  snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
++  return buff;
++}
++
++static bool
++print_stapsdt_note (Elf_Internal_Note *pnote)
++{
++  size_t len, maxlen;
++  unsigned long addr_size = is_32bit_elf ? 4 : 8;
++  char *data = pnote->descdata;
++  char *data_end = pnote->descdata + pnote->descsz;
++  bfd_vma pc, base_addr, semaphore;
++  char *provider, *probe, *arg_fmt;
++
++  if (pnote->descsz < (addr_size * 3))
++    goto stapdt_note_too_small;
++
++  pc = byte_get ((unsigned char *) data, addr_size);
++  data += addr_size;
++
++  base_addr = byte_get ((unsigned char *) data, addr_size);
++  data += addr_size;
++
++  semaphore = byte_get ((unsigned char *) data, addr_size);
++  data += addr_size;
++
++  if (data >= data_end)
++    goto stapdt_note_too_small;
++  maxlen = data_end - data;
++  len = strnlen (data, maxlen);
++  if (len < maxlen)
++    {
++      provider = data;
++      data += len + 1;
++    }
++  else
++    goto stapdt_note_too_small;
++
++  if (data >= data_end)
++    goto stapdt_note_too_small;
++  maxlen = data_end - data;
++  len = strnlen (data, maxlen);
++  if (len < maxlen)
++    {
++      probe = data;
++      data += len + 1;
++    }
++  else
++    goto stapdt_note_too_small;
++
++  if (data >= data_end)
++    goto stapdt_note_too_small;
++  maxlen = data_end - data;
++  len = strnlen (data, maxlen);
++  if (len < maxlen)
++    {
++      arg_fmt = data;
++      data += len + 1;
++    }
++  else
++    goto stapdt_note_too_small;
++
++  printf (_("    Provider: %s\n"), provider);
++  printf (_("    Name: %s\n"), probe);
++  printf (_("    Location: "));
++  print_vma (pc, FULL_HEX);
++  printf (_(", Base: "));
++  print_vma (base_addr, FULL_HEX);
++  printf (_(", Semaphore: "));
++  print_vma (semaphore, FULL_HEX);
++  printf ("\n");
++  printf (_("    Arguments: %s\n"), arg_fmt);
++
++  return data == data_end;
++
++ stapdt_note_too_small:
++  printf (_("  <corrupt - note is too small>\n"));
++  error (_("corrupt stapdt note - the data size is too small\n"));
++  return false;
++}
++
++static const char *
++get_ia64_vms_note_type (unsigned e_type)
++{
++  static char buff[64];
++
++  switch (e_type)
++    {
++    case NT_VMS_MHD:
++      return _("NT_VMS_MHD (module header)");
++    case NT_VMS_LNM:
++      return _("NT_VMS_LNM (language name)");
++    case NT_VMS_SRC:
++      return _("NT_VMS_SRC (source files)");
++    case NT_VMS_TITLE:
++      return "NT_VMS_TITLE";
++    case NT_VMS_EIDC:
++      return _("NT_VMS_EIDC (consistency check)");
++    case NT_VMS_FPMODE:
++      return _("NT_VMS_FPMODE (FP mode)");
++    case NT_VMS_LINKTIME:
++      return "NT_VMS_LINKTIME";
++    case NT_VMS_IMGNAM:
++      return _("NT_VMS_IMGNAM (image name)");
++    case NT_VMS_IMGID:
++      return _("NT_VMS_IMGID (image id)");
++    case NT_VMS_LINKID:
++      return _("NT_VMS_LINKID (link id)");
++    case NT_VMS_IMGBID:
++      return _("NT_VMS_IMGBID (build id)");
++    case NT_VMS_GSTNAM:
++      return _("NT_VMS_GSTNAM (sym table name)");
++    case NT_VMS_ORIG_DYN:
++      return "NT_VMS_ORIG_DYN";
++    case NT_VMS_PATCHTIME:
++      return "NT_VMS_PATCHTIME";
++    default:
++      snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
++      return buff;
++    }
++}
++
++static bool
++print_ia64_vms_note (Elf_Internal_Note * pnote)
++{
++  int maxlen = pnote->descsz;
++
++  if (maxlen < 2 || (unsigned long) maxlen != pnote->descsz)
++    goto desc_size_fail;
++
++  switch (pnote->type)
++    {
++    case NT_VMS_MHD:
++      if (maxlen <= 36)
++	goto desc_size_fail;
++
++      int l = (int) strnlen (pnote->descdata + 34, maxlen - 34);
++
++      printf (_("    Creation date  : %.17s\n"), pnote->descdata);
++      printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
++      if (l + 34 < maxlen)
++	{
++	  printf (_("    Module name    : %s\n"), pnote->descdata + 34);
++	  if (l + 35 < maxlen)
++	    printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
++	  else
++	    printf (_("    Module version : <missing>\n"));
++	}
++      else
++	{
++	  printf (_("    Module name    : <missing>\n"));
++	  printf (_("    Module version : <missing>\n"));
++	}
++      break;
++
++    case NT_VMS_LNM:
++      printf (_("   Language: %.*s\n"), maxlen, pnote->descdata);
++      break;
++
++#ifdef BFD64
++    case NT_VMS_FPMODE:
++      printf (_("   Floating Point mode: "));
++      if (maxlen < 8)
++	goto desc_size_fail;
++      /* FIXME: Generate an error if descsz > 8 ?  */
++
++      printf ("0x%016" BFD_VMA_FMT "x\n",
++	      (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
++      break;
++
++    case NT_VMS_LINKTIME:
++      printf (_("   Link time: "));
++      if (maxlen < 8)
++	goto desc_size_fail;
++      /* FIXME: Generate an error if descsz > 8 ?  */
++
++      print_vms_time
++	((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
++      printf ("\n");
++      break;
++
++    case NT_VMS_PATCHTIME:
++      printf (_("   Patch time: "));
++      if (maxlen < 8)
++	goto desc_size_fail;
++      /* FIXME: Generate an error if descsz > 8 ?  */
++
++      print_vms_time
++	((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
++      printf ("\n");
++      break;
++
++    case NT_VMS_ORIG_DYN:
++      if (maxlen < 34)
++	goto desc_size_fail;
++
++      printf (_("   Major id: %u,  minor id: %u\n"),
++              (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
++              (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
++      printf (_("   Last modified  : "));
++      print_vms_time
++        ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
++      printf (_("\n   Link flags  : "));
++      printf ("0x%016" BFD_VMA_FMT "x\n",
++              (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
++      printf (_("   Header flags: 0x%08x\n"),
++              (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
++      printf (_("   Image id    : %.*s\n"), maxlen - 32, pnote->descdata + 32);
++      break;
++#endif
++
++    case NT_VMS_IMGNAM:
++      printf (_("    Image name: %.*s\n"), maxlen, pnote->descdata);
++      break;
++
++    case NT_VMS_GSTNAM:
++      printf (_("    Global symbol table name: %.*s\n"), maxlen, pnote->descdata);
++      break;
++
++    case NT_VMS_IMGID:
++      printf (_("    Image id: %.*s\n"), maxlen, pnote->descdata);
++      break;
++
++    case NT_VMS_LINKID:
++      printf (_("    Linker id: %.*s\n"), maxlen, pnote->descdata);
++      break;
++
++    default:
++      return false;
++    }
++
++  return true;
++
++ desc_size_fail:
++  printf (_("  <corrupt - data size is too small>\n"));
++  error (_("corrupt IA64 note: data size is too small\n"));
++  return false;
++}
++
++struct build_attr_cache {
++  Filedata *filedata;
++  char *strtab;
++  unsigned long strtablen;
++  Elf_Internal_Sym *symtab;
++  unsigned long nsyms;
++} ba_cache;
++
++/* Find the symbol associated with a build attribute that is attached
++   to address OFFSET.  If PNAME is non-NULL then store the name of
++   the symbol (if found) in the provided pointer,  Returns NULL if a
++   symbol could not be found.  */
++
++static Elf_Internal_Sym *
++get_symbol_for_build_attribute (Filedata *filedata,
++				unsigned long offset,
++				bool is_open_attr,
++				const char **pname)
++{
++  Elf_Internal_Sym *saved_sym = NULL;
++  Elf_Internal_Sym *sym;
++
++  if (filedata->section_headers != NULL
++      && (ba_cache.filedata == NULL || filedata != ba_cache.filedata))
++    {
++      Elf_Internal_Shdr * symsec;
++
++      free (ba_cache.strtab);
++      ba_cache.strtab = NULL;
++      free (ba_cache.symtab);
++      ba_cache.symtab = NULL;
++
++      /* Load the symbol and string sections.  */
++      for (symsec = filedata->section_headers;
++	   symsec < filedata->section_headers + filedata->file_header.e_shnum;
++	   symsec ++)
++	{
++	  if (symsec->sh_type == SHT_SYMTAB
++	      && get_symtab (filedata, symsec,
++			     &ba_cache.symtab, &ba_cache.nsyms,
++			     &ba_cache.strtab, &ba_cache.strtablen))
++	    break;
++	}
++      ba_cache.filedata = filedata;
++    }
++
++  if (ba_cache.symtab == NULL)
++    return NULL;
++
++  /* Find a symbol whose value matches offset.  */
++  for (sym = ba_cache.symtab; sym < ba_cache.symtab + ba_cache.nsyms; sym ++)
++    if (sym->st_value == offset)
++      {
++	if (sym->st_name >= ba_cache.strtablen)
++	  /* Huh ?  This should not happen.  */
++	  continue;
++
++	if (ba_cache.strtab[sym->st_name] == 0)
++	  continue;
++
++	/* The AArch64 and ARM architectures define mapping symbols
++	   (eg $d, $x, $t) which we want to ignore.  */
++	if (ba_cache.strtab[sym->st_name] == '$'
++	    && ba_cache.strtab[sym->st_name + 1] != 0
++	    && ba_cache.strtab[sym->st_name + 2] == 0)
++	  continue;
++
++	if (is_open_attr)
++	  {
++	    /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
++	       and FILE or OBJECT symbols over NOTYPE symbols.  We skip
++	       FUNC symbols entirely.  */
++	    switch (ELF_ST_TYPE (sym->st_info))
++	      {
++	      case STT_OBJECT:
++	      case STT_FILE:
++		saved_sym = sym;
++		if (sym->st_size)
++		  {
++		    /* If the symbol has a size associated
++		       with it then we can stop searching.  */
++		    sym = ba_cache.symtab + ba_cache.nsyms;
++		  }
++		continue;
++
++	      case STT_FUNC:
++		/* Ignore function symbols.  */
++		continue;
++
++	      default:
++		break;
++	      }
++
++	    switch (ELF_ST_BIND (sym->st_info))
++	      {
++	      case STB_GLOBAL:
++		if (saved_sym == NULL
++		    || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
++		  saved_sym = sym;
++		break;
++
++	      case STB_LOCAL:
++		if (saved_sym == NULL)
++		  saved_sym = sym;
++		break;
++
++	      default:
++		break;
++	      }
++	  }
++	else
++	  {
++	    if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
++	      continue;
++
++	    saved_sym = sym;
++	    break;
++	  }
++      }
++
++  if (saved_sym && pname)
++    * pname = ba_cache.strtab + saved_sym->st_name;
++
++  return saved_sym;
++}
++
++/* Returns true iff addr1 and addr2 are in the same section.  */
++
++static bool
++same_section (Filedata * filedata, unsigned long addr1, unsigned long addr2)
++{
++  Elf_Internal_Shdr * a1;
++  Elf_Internal_Shdr * a2;
++
++  a1 = find_section_by_address (filedata, addr1);
++  a2 = find_section_by_address (filedata, addr2);
++
++  return a1 == a2 && a1 != NULL;
++}
++
++static bool
++print_gnu_build_attribute_description (Elf_Internal_Note *  pnote,
++				       Filedata *           filedata)
++{
++  static unsigned long global_offset = 0;
++  static unsigned long global_end = 0;
++  static unsigned long func_offset = 0;
++  static unsigned long func_end = 0;
++
++  Elf_Internal_Sym *sym;
++  const char *name;
++  unsigned long start;
++  unsigned long end;
++  bool is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
++
++  switch (pnote->descsz)
++    {
++    case 0:
++      /* A zero-length description means that the range of
++	 the previous note of the same type should be used.  */
++      if (is_open_attr)
++	{
++	  if (global_end > global_offset)
++	    printf (_("    Applies to region from %#lx to %#lx\n"),
++		    global_offset, global_end);
++	  else
++	    printf (_("    Applies to region from %#lx\n"), global_offset);
++	}
++      else
++	{
++	  if (func_end > func_offset)
++	    printf (_("    Applies to region from %#lx to %#lx\n"), func_offset, func_end);
++	  else
++	    printf (_("    Applies to region from %#lx\n"), func_offset);
++	}
++      return true;
++
++    case 4:
++      start = byte_get ((unsigned char *) pnote->descdata, 4);
++      end = 0;
++      break;
++
++    case 8:
++      start = byte_get ((unsigned char *) pnote->descdata, 4);
++      end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
++      break;
++
++    case 16:
++      start = byte_get ((unsigned char *) pnote->descdata, 8);
++      end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
++      break;
++
++    default:
++      error (_("    <invalid description size: %lx>\n"), pnote->descsz);
++      printf (_("    <invalid descsz>"));
++      return false;
++    }
++
++  name = NULL;
++  sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
++  /* As of version 5 of the annobin plugin, filename symbols are biased by 2
++     in order to avoid them being confused with the start address of the
++     first function in the file...  */
++  if (sym == NULL && is_open_attr)
++    sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
++					  & name);
++
++  if (end == 0 && sym != NULL && sym->st_size > 0)
++    end = start + sym->st_size;
++
++  if (is_open_attr)
++    {
++      /* FIXME: Need to properly allow for section alignment.
++	 16 is just the alignment used on x86_64.  */
++      if (global_end > 0
++	  && start > BFD_ALIGN (global_end, 16)
++	  /* Build notes are not guaranteed to be organised in order of
++	     increasing address, but we should find the all of the notes
++	     for one section in the same place.  */
++	  && same_section (filedata, start, global_end))
++	warn (_("Gap in build notes detected from %#lx to %#lx\n"),
++	      global_end + 1, start - 1);
++
++      printf (_("    Applies to region from %#lx"), start);
++      global_offset = start;
++
++      if (end)
++	{
++	  printf (_(" to %#lx"), end);
++	  global_end = end;
++	}
++    }
++  else
++    {
++      printf (_("    Applies to region from %#lx"), start);
++      func_offset = start;
++
++      if (end)
++	{
++	  printf (_(" to %#lx"), end);
++	  func_end = end;
++	}
++    }
++
++  if (sym && name)
++    printf (_(" (%s)"), name);
++
++  printf ("\n");
++  return true;
++}
++
++static bool
++print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
++{
++  static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
++  static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
++  static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
++  char         name_type;
++  char         name_attribute;
++  const char * expected_types;
++  const char * name = pnote->namedata;
++  const char * text;
++  signed int   left;
++
++  if (name == NULL || pnote->namesz < 2)
++    {
++      error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
++      print_symbol (-20, _("  <corrupt name>"));
++      return false;
++    }
++
++  if (do_wide)
++    left = 28;
++  else
++    left = 20;
++
++  /* Version 2 of the spec adds a "GA" prefix to the name field.  */
++  if (name[0] == 'G' && name[1] == 'A')
++    {
++      if (pnote->namesz < 4)
++	{
++	  error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
++	  print_symbol (-20, _("  <corrupt name>"));
++	  return false;
++	}
++
++      printf ("GA");
++      name += 2;
++      left -= 2;
++    }
++
++  switch ((name_type = * name))
++    {
++    case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
++    case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
++    case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
++    case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
++      printf ("%c", * name);
++      left --;
++      break;
++    default:
++      error (_("unrecognised attribute type in name field: %d\n"), name_type);
++      print_symbol (-20, _("<unknown name type>"));
++      return false;
++    }
++
++  ++ name;
++  text = NULL;
++
++  switch ((name_attribute = * name))
++    {
++    case GNU_BUILD_ATTRIBUTE_VERSION:
++      text = _("<version>");
++      expected_types = string_expected;
++      ++ name;
++      break;
++    case GNU_BUILD_ATTRIBUTE_STACK_PROT:
++      text = _("<stack prot>");
++      expected_types = "!+*";
++      ++ name;
++      break;
++    case GNU_BUILD_ATTRIBUTE_RELRO:
++      text = _("<relro>");
++      expected_types = bool_expected;
++      ++ name;
++      break;
++    case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
++      text = _("<stack size>");
++      expected_types = number_expected;
++      ++ name;
++      break;
++    case GNU_BUILD_ATTRIBUTE_TOOL:
++      text = _("<tool>");
++      expected_types = string_expected;
++      ++ name;
++      break;
++    case GNU_BUILD_ATTRIBUTE_ABI:
++      text = _("<ABI>");
++      expected_types = "$*";
++      ++ name;
++      break;
++    case GNU_BUILD_ATTRIBUTE_PIC:
++      text = _("<PIC>");
++      expected_types = number_expected;
++      ++ name;
++      break;
++    case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
++      text = _("<short enum>");
++      expected_types = bool_expected;
++      ++ name;
++      break;
++    default:
++      if (ISPRINT (* name))
++	{
++	  int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
++
++	  if (len > left && ! do_wide)
++	    len = left;
++	  printf ("%.*s:", len, name);
++	  left -= len;
++	  name += len;
++	}
++      else
++	{
++	  static char tmpbuf [128];
++
++	  error (_("unrecognised byte in name field: %d\n"), * name);
++	  sprintf (tmpbuf, _("<unknown:_%d>"), * name);
++	  text = tmpbuf;
++	  name ++;
++	}
++      expected_types = "*$!+";
++      break;
++    }
++
++  if (text)
++    left -= printf ("%s", text);
++
++  if (strchr (expected_types, name_type) == NULL)
++    warn (_("attribute does not have an expected type (%c)\n"), name_type);
++
++  if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
++    {
++      error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
++	     (unsigned long) pnote->namesz,
++	     (long) (name - pnote->namedata));
++      return false;
++    }
++
++  if (left < 1 && ! do_wide)
++    return true;
++
++  switch (name_type)
++    {
++    case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
++      {
++	unsigned int        bytes;
++	unsigned long long  val = 0;
++	unsigned int        shift = 0;
++	char *              decoded = NULL;
++
++	bytes = pnote->namesz - (name - pnote->namedata);
++	if (bytes > 0)
++	  /* The -1 is because the name field is always 0 terminated, and we
++	     want to be able to ensure that the shift in the while loop below
++	     will not overflow.  */
++	  -- bytes;
++
++	if (bytes > sizeof (val))
++	  {
++	    error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
++		   bytes);
++	    bytes = sizeof (val);
++	  }
++	/* We do not bother to warn if bytes == 0 as this can
++	   happen with some early versions of the gcc plugin.  */
++
++	while (bytes --)
++	  {
++	    unsigned long long byte = *name++ & 0xff;
++
++	    val |= byte << shift;
++	    shift += 8;
++	  }
++
++	switch (name_attribute)
++	  {
++	  case GNU_BUILD_ATTRIBUTE_PIC:
++	    switch (val)
++	      {
++	      case 0: decoded = "static"; break;
++	      case 1: decoded = "pic"; break;
++	      case 2: decoded = "PIC"; break;
++	      case 3: decoded = "pie"; break;
++	      case 4: decoded = "PIE"; break;
++	      default: break;
++	      }
++	    break;
++	  case GNU_BUILD_ATTRIBUTE_STACK_PROT:
++	    switch (val)
++	      {
++		/* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
++	      case 0: decoded = "off"; break;
++	      case 1: decoded = "on"; break;
++	      case 2: decoded = "all"; break;
++	      case 3: decoded = "strong"; break;
++	      case 4: decoded = "explicit"; break;
++	      default: break;
++	      }
++	    break;
++	  default:
++	    break;
++	  }
++
++	if (decoded != NULL)
++	  {
++	    print_symbol (-left, decoded);
++	    left = 0;
++	  }
++	else if (val == 0)
++	  {
++	    printf ("0x0");
++	    left -= 3;
++	  }
++	else
++	  {
++	    if (do_wide)
++	      left -= printf ("0x%llx", val);
++	    else
++	      left -= printf ("0x%-.*llx", left, val);
++	  }
++      }
++      break;
++    case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
++      left -= print_symbol (- left, name);
++      break;
++    case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
++      left -= print_symbol (- left, "true");
++      break;
++    case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
++      left -= print_symbol (- left, "false");
++      break;
++    }
++
++  if (do_wide && left > 0)
++    printf ("%-*s", left, " ");
++
++  return true;
++}
++
++/* Note that by the ELF standard, the name field is already null byte
++   terminated, and namesz includes the terminating null byte.
++   I.E. the value of namesz for the name "FSF" is 4.
++
++   If the value of namesz is zero, there is no name present.  */
++
++static bool
++process_note (Elf_Internal_Note *  pnote,
++	      Filedata *           filedata)
++{
++  const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
++  const char * nt;
++
++  if (pnote->namesz == 0)
++    /* If there is no note name, then use the default set of
++       note type strings.  */
++    nt = get_note_type (filedata, pnote->type);
++
++  else if (startswith (pnote->namedata, "GNU"))
++    /* GNU-specific object file notes.  */
++    nt = get_gnu_elf_note_type (pnote->type);
++
++  else if (startswith (pnote->namedata, "FreeBSD"))
++    /* FreeBSD-specific core file notes.  */
++    nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
++
++  else if (startswith (pnote->namedata, "NetBSD-CORE"))
++    /* NetBSD-specific core file notes.  */
++    nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
++
++  else if (startswith (pnote->namedata, "NetBSD"))
++    /* NetBSD-specific core file notes.  */
++    return process_netbsd_elf_note (pnote);
++
++  else if (startswith (pnote->namedata, "PaX"))
++    /* NetBSD-specific core file notes.  */
++    return process_netbsd_elf_note (pnote);
++
++  else if (startswith (pnote->namedata, "SPU/"))
++    {
++      /* SPU-specific core file notes.  */
++      nt = pnote->namedata + 4;
++      name = "SPU";
++    }
++
++  else if (startswith (pnote->namedata, "IPF/VMS"))
++    /* VMS/ia64-specific file notes.  */
++    nt = get_ia64_vms_note_type (pnote->type);
++
++  else if (startswith (pnote->namedata, "stapsdt"))
++    nt = get_stapsdt_note_type (pnote->type);
++
++  else
++    /* Don't recognize this note name; just use the default set of
++       note type strings.  */
++    nt = get_note_type (filedata, pnote->type);
++
++  printf ("  ");
++
++  if (((startswith (pnote->namedata, "GA")
++	&& strchr ("*$!+", pnote->namedata[2]) != NULL)
++       || strchr ("*$!+", pnote->namedata[0]) != NULL)
++      && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
++	  || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
++    print_gnu_build_attribute_name (pnote);
++  else
++    print_symbol (-20, name);
++
++  if (do_wide)
++    printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
++  else
++    printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
++
++  if (startswith (pnote->namedata, "IPF/VMS"))
++    return print_ia64_vms_note (pnote);
++  else if (startswith (pnote->namedata, "GNU"))
++    return print_gnu_note (filedata, pnote);
++  else if (startswith (pnote->namedata, "stapsdt"))
++    return print_stapsdt_note (pnote);
++  else if (startswith (pnote->namedata, "CORE"))
++    return print_core_note (pnote);
++  else if (((startswith (pnote->namedata, "GA")
++	     && strchr ("*$!+", pnote->namedata[2]) != NULL)
++	    || strchr ("*$!+", pnote->namedata[0]) != NULL)
++	   && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
++	       || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
++    return print_gnu_build_attribute_description (pnote, filedata);
++
++  if (pnote->descsz)
++    {
++      unsigned long i;
++
++      printf (_("   description data: "));
++      for (i = 0; i < pnote->descsz; i++)
++	printf ("%02x ", pnote->descdata[i] & 0xff);
++      if (!do_wide)
++	printf ("\n");
++    }
++
++  if (do_wide)
++    printf ("\n");
++
++  return true;
++}
++
++static bool
++process_notes_at (Filedata *           filedata,
++		  Elf_Internal_Shdr *  section,
++		  bfd_vma              offset,
++		  bfd_vma              length,
++		  bfd_vma              align)
++{
++  Elf_External_Note *pnotes;
++  Elf_External_Note *external;
++  char *end;
++  bool res = true;
++
++  if (length <= 0)
++    return false;
++
++  if (section)
++    {
++      pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
++      if (pnotes)
++	{
++	  if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
++	    {
++	      free (pnotes);
++	      return false;
++	    }
++	}
++    }
++  else
++    pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
++					     _("notes"));
++
++  if (pnotes == NULL)
++    return false;
++
++  external = pnotes;
++
++  if (filedata->is_separate)
++    printf (_("In linked file '%s': "), filedata->file_name);
++  else
++    printf ("\n");
++  if (section)
++    printf (_("Displaying notes found in: %s\n"), printable_section_name (filedata, section));
++  else
++    printf (_("Displaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
++	    (unsigned long) offset, (unsigned long) length);
++
++  /* NB: Some note sections may have alignment value of 0 or 1.  gABI
++     specifies that notes should be aligned to 4 bytes in 32-bit
++     objects and to 8 bytes in 64-bit objects.  As a Linux extension,
++     we also support 4 byte alignment in 64-bit objects.  If section
++     alignment is less than 4, we treate alignment as 4 bytes.   */
++  if (align < 4)
++    align = 4;
++  else if (align != 4 && align != 8)
++    {
++      warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
++	    (long) align);
++      free (pnotes);
++      return false;
++    }
++
++  printf (_("  %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
++
++  end = (char *) pnotes + length;
++  while ((char *) external < end)
++    {
++      Elf_Internal_Note inote;
++      size_t min_notesz;
++      char * next;
++      char * temp = NULL;
++      size_t data_remaining = end - (char *) external;
++
++      if (!is_ia64_vms (filedata))
++	{
++	  /* PR binutils/15191
++	     Make sure that there is enough data to read.  */
++	  min_notesz = offsetof (Elf_External_Note, name);
++	  if (data_remaining < min_notesz)
++	    {
++	      warn (ngettext ("Corrupt note: only %ld byte remains, "
++			      "not enough for a full note\n",
++			      "Corrupt note: only %ld bytes remain, "
++			      "not enough for a full note\n",
++			      data_remaining),
++		    (long) data_remaining);
++	      break;
++	    }
++	  data_remaining -= min_notesz;
++
++	  inote.type     = BYTE_GET (external->type);
++	  inote.namesz   = BYTE_GET (external->namesz);
++	  inote.namedata = external->name;
++	  inote.descsz   = BYTE_GET (external->descsz);
++	  inote.descdata = ((char *) external
++			    + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
++	  inote.descpos  = offset + (inote.descdata - (char *) pnotes);
++	  next = ((char *) external
++		  + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
++	}
++      else
++	{
++	  Elf64_External_VMS_Note *vms_external;
++
++	  /* PR binutils/15191
++	     Make sure that there is enough data to read.  */
++	  min_notesz = offsetof (Elf64_External_VMS_Note, name);
++	  if (data_remaining < min_notesz)
++	    {
++	      warn (ngettext ("Corrupt note: only %ld byte remains, "
++			      "not enough for a full note\n",
++			      "Corrupt note: only %ld bytes remain, "
++			      "not enough for a full note\n",
++			      data_remaining),
++		    (long) data_remaining);
++	      break;
++	    }
++	  data_remaining -= min_notesz;
++
++	  vms_external = (Elf64_External_VMS_Note *) external;
++	  inote.type     = BYTE_GET (vms_external->type);
++	  inote.namesz   = BYTE_GET (vms_external->namesz);
++	  inote.namedata = vms_external->name;
++	  inote.descsz   = BYTE_GET (vms_external->descsz);
++	  inote.descdata = inote.namedata + align_power (inote.namesz, 3);
++	  inote.descpos  = offset + (inote.descdata - (char *) pnotes);
++	  next = inote.descdata + align_power (inote.descsz, 3);
++	}
++
++      /* PR 17531: file: 3443835e.  */
++      /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
++      if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
++	  || (size_t) (inote.descdata - inote.namedata) > data_remaining
++	  || (size_t) (next - inote.descdata) < inote.descsz
++	  || ((size_t) (next - inote.descdata)
++	      > data_remaining - (size_t) (inote.descdata - inote.namedata)))
++	{
++	  warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
++		(unsigned long) ((char *) external - (char *) pnotes));
++	  warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
++		inote.type, inote.namesz, inote.descsz, (int) align);
++	  break;
++	}
++
++      external = (Elf_External_Note *) next;
++
++      /* Verify that name is null terminated.  It appears that at least
++	 one version of Linux (RedHat 6.0) generates corefiles that don't
++	 comply with the ELF spec by failing to include the null byte in
++	 namesz.  */
++      if (inote.namesz > 0 && inote.namedata[inote.namesz - 1] != '\0')
++	{
++	  if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
++	    {
++	      temp = (char *) malloc (inote.namesz + 1);
++	      if (temp == NULL)
++		{
++		  error (_("Out of memory allocating space for inote name\n"));
++		  res = false;
++		  break;
++		}
++
++	      memcpy (temp, inote.namedata, inote.namesz);
++	      inote.namedata = temp;
++	    }
++	  inote.namedata[inote.namesz] = 0;
++	}
++
++      if (! process_note (& inote, filedata))
++	res = false;
++
++      free (temp);
++      temp = NULL;
++    }
++
++  free (pnotes);
++
++  return res;
++}
++
++static bool
++process_corefile_note_segments (Filedata * filedata)
++{
++  Elf_Internal_Phdr *segment;
++  unsigned int i;
++  bool res = true;
++
++  if (! get_program_headers (filedata))
++    return true;
++
++  for (i = 0, segment = filedata->program_headers;
++       i < filedata->file_header.e_phnum;
++       i++, segment++)
++    {
++      if (segment->p_type == PT_NOTE)
++	if (! process_notes_at (filedata, NULL,
++				(bfd_vma) segment->p_offset,
++				(bfd_vma) segment->p_filesz,
++				(bfd_vma) segment->p_align))
++	  res = false;
++    }
++
++  return res;
++}
++
++static bool
++process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
++{
++  Elf_External_Note * pnotes;
++  Elf_External_Note * external;
++  char * end;
++  bool res = true;
++
++  if (length <= 0)
++    return false;
++
++  pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
++                                           _("v850 notes"));
++  if (pnotes == NULL)
++    return false;
++
++  external = pnotes;
++  end = (char*) pnotes + length;
++
++  printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
++	  (unsigned long) offset, (unsigned long) length);
++
++  while ((char *) external + sizeof (Elf_External_Note) < end)
++    {
++      Elf_External_Note * next;
++      Elf_Internal_Note inote;
++
++      inote.type     = BYTE_GET (external->type);
++      inote.namesz   = BYTE_GET (external->namesz);
++      inote.namedata = external->name;
++      inote.descsz   = BYTE_GET (external->descsz);
++      inote.descdata = inote.namedata + align_power (inote.namesz, 2);
++      inote.descpos  = offset + (inote.descdata - (char *) pnotes);
++
++      if (inote.descdata < (char *) pnotes || inote.descdata >= end)
++	{
++	  warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
++	  inote.descdata = inote.namedata;
++	  inote.namesz   = 0;
++	}
++
++      next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
++
++      if (   ((char *) next > end)
++	  || ((char *) next <  (char *) pnotes))
++	{
++	  warn (_("corrupt descsz found in note at offset 0x%lx\n"),
++		(unsigned long) ((char *) external - (char *) pnotes));
++	  warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
++		inote.type, inote.namesz, inote.descsz);
++	  break;
++	}
++
++      external = next;
++
++      /* Prevent out-of-bounds indexing.  */
++      if (   inote.namedata + inote.namesz > end
++	  || inote.namedata + inote.namesz < inote.namedata)
++        {
++          warn (_("corrupt namesz found in note at offset 0x%lx\n"),
++                (unsigned long) ((char *) external - (char *) pnotes));
++          warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
++                inote.type, inote.namesz, inote.descsz);
++          break;
++        }
++
++      printf ("  %s: ", get_v850_elf_note_type (inote.type));
++
++      if (! print_v850_note (& inote))
++	{
++	  res = false;
++	  printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
++		  inote.namesz, inote.descsz);
++	}
++    }
++
++  free (pnotes);
++
++  return res;
++}
++
++static bool
++process_note_sections (Filedata * filedata)
++{
++  Elf_Internal_Shdr *section;
++  unsigned long i;
++  unsigned int n = 0;
++  bool res = true;
++
++  for (i = 0, section = filedata->section_headers;
++       i < filedata->file_header.e_shnum && section != NULL;
++       i++, section++)
++    {
++      if (section->sh_type == SHT_NOTE)
++	{
++	  if (! process_notes_at (filedata, section,
++				  (bfd_vma) section->sh_offset,
++				  (bfd_vma) section->sh_size,
++				  (bfd_vma) section->sh_addralign))
++	    res = false;
++	  n++;
++	}
++
++      if ((   filedata->file_header.e_machine == EM_V800
++	   || filedata->file_header.e_machine == EM_V850
++	   || filedata->file_header.e_machine == EM_CYGNUS_V850)
++	  && section->sh_type == SHT_RENESAS_INFO)
++	{
++	  if (! process_v850_notes (filedata,
++				    (bfd_vma) section->sh_offset,
++				    (bfd_vma) section->sh_size))
++	    res = false;
++	  n++;
++	}
++    }
++
++  if (n == 0)
++    /* Try processing NOTE segments instead.  */
++    return process_corefile_note_segments (filedata);
++
++  return res;
++}
++
++static bool
++process_notes (Filedata * filedata)
++{
++  /* If we have not been asked to display the notes then do nothing.  */
++  if (! do_notes)
++    return true;
++
++  if (filedata->file_header.e_type != ET_CORE)
++    return process_note_sections (filedata);
++
++  /* No program headers means no NOTE segment.  */
++  if (filedata->file_header.e_phnum > 0)
++    return process_corefile_note_segments (filedata);
++
++  if (filedata->is_separate)
++    printf (_("No notes found in linked file '%s'.\n"),
++	    filedata->file_name);
++  else
++    printf (_("No notes found file.\n"));
++
++  return true;
++}
++
++static unsigned char *
++display_public_gnu_attributes (unsigned char * start,
++			       const unsigned char * const end)
++{
++  printf (_("  Unknown GNU attribute: %s\n"), start);
++
++  start += strnlen ((char *) start, end - start);
++  display_raw_attribute (start, end);
++
++  return (unsigned char *) end;
++}
++
++static unsigned char *
++display_generic_attribute (unsigned char * start,
++			   unsigned int tag,
++			   const unsigned char * const end)
++{
++  if (tag == 0)
++    return (unsigned char *) end;
++
++  return display_tag_value (tag, start, end);
++}
++
++static bool
++process_arch_specific (Filedata * filedata)
++{
++  if (! do_arch)
++    return true;
++
++  switch (filedata->file_header.e_machine)
++    {
++    case EM_ARC:
++    case EM_ARC_COMPACT:
++    case EM_ARC_COMPACT2:
++      return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
++				 display_arc_attribute,
++				 display_generic_attribute);
++    case EM_ARM:
++      return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
++				 display_arm_attribute,
++				 display_generic_attribute);
++
++    case EM_MIPS:
++    case EM_MIPS_RS3_LE:
++      return process_mips_specific (filedata);
++
++    case EM_MSP430:
++     return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
++				display_msp430_attribute,
++				display_msp430_gnu_attribute);
++
++    case EM_RISCV:
++     return process_attributes (filedata, "riscv", SHT_RISCV_ATTRIBUTES,
++				display_riscv_attribute,
++				display_generic_attribute);
++
++    case EM_NDS32:
++      return process_nds32_specific (filedata);
++
++    case EM_68K:
++      return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
++				 display_m68k_gnu_attribute);
++
++    case EM_PPC:
++    case EM_PPC64:
++      return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
++				 display_power_gnu_attribute);
++
++    case EM_S390:
++    case EM_S390_OLD:
++      return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
++				 display_s390_gnu_attribute);
++
++    case EM_SPARC:
++    case EM_SPARC32PLUS:
++    case EM_SPARCV9:
++      return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
++				 display_sparc_gnu_attribute);
++
++    case EM_TI_C6000:
++      return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
++				 display_tic6x_attribute,
++				 display_generic_attribute);
++
++    case EM_CSKY:
++      return process_attributes (filedata, "csky", SHT_CSKY_ATTRIBUTES,
++				 display_csky_attribute, NULL);
++
++    default:
++      return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
++				 display_public_gnu_attributes,
++				 display_generic_attribute);
++    }
++}
++
++static bool
++get_file_header (Filedata * filedata)
++{
++  /* Read in the identity array.  */
++  if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
++    return false;
++
++  /* Determine how to read the rest of the header.  */
++  switch (filedata->file_header.e_ident[EI_DATA])
++    {
++    default:
++    case ELFDATANONE:
++    case ELFDATA2LSB:
++      byte_get = byte_get_little_endian;
++      byte_put = byte_put_little_endian;
++      break;
++    case ELFDATA2MSB:
++      byte_get = byte_get_big_endian;
++      byte_put = byte_put_big_endian;
++      break;
++    }
++
++  /* For now we only support 32 bit and 64 bit ELF files.  */
++  is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
++
++  /* Read in the rest of the header.  */
++  if (is_32bit_elf)
++    {
++      Elf32_External_Ehdr ehdr32;
++
++      if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
++	return false;
++
++      filedata->file_header.e_type      = BYTE_GET (ehdr32.e_type);
++      filedata->file_header.e_machine   = BYTE_GET (ehdr32.e_machine);
++      filedata->file_header.e_version   = BYTE_GET (ehdr32.e_version);
++      filedata->file_header.e_entry     = BYTE_GET (ehdr32.e_entry);
++      filedata->file_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
++      filedata->file_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
++      filedata->file_header.e_flags     = BYTE_GET (ehdr32.e_flags);
++      filedata->file_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
++      filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
++      filedata->file_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
++      filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
++      filedata->file_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
++      filedata->file_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
++    }
++  else
++    {
++      Elf64_External_Ehdr ehdr64;
++
++      /* If we have been compiled with sizeof (bfd_vma) == 4, then
++	 we will not be able to cope with the 64bit data found in
++	 64 ELF files.  Detect this now and abort before we start
++	 overwriting things.  */
++      if (sizeof (bfd_vma) < 8)
++	{
++	  error (_("This instance of readelf has been built without support for a\n\
++64 bit data type and so it cannot read 64 bit ELF files.\n"));
++	  return false;
++	}
++
++      if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
++	return false;
++
++      filedata->file_header.e_type      = BYTE_GET (ehdr64.e_type);
++      filedata->file_header.e_machine   = BYTE_GET (ehdr64.e_machine);
++      filedata->file_header.e_version   = BYTE_GET (ehdr64.e_version);
++      filedata->file_header.e_entry     = BYTE_GET (ehdr64.e_entry);
++      filedata->file_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
++      filedata->file_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
++      filedata->file_header.e_flags     = BYTE_GET (ehdr64.e_flags);
++      filedata->file_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
++      filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
++      filedata->file_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
++      filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
++      filedata->file_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
++      filedata->file_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
++    }
++
++  return true;
++}
++
++static void
++free_filedata (Filedata *filedata)
++{
++  free (filedata->program_interpreter);
++  free (filedata->program_headers);
++  free (filedata->section_headers);
++  free (filedata->string_table);
++  free (filedata->dump.dump_sects);
++  free (filedata->dynamic_strings);
++  free (filedata->dynamic_symbols);
++  free (filedata->dynamic_syminfo);
++  free (filedata->dynamic_section);
++
++  while (filedata->symtab_shndx_list != NULL)
++    {
++      elf_section_list *next = filedata->symtab_shndx_list->next;
++      free (filedata->symtab_shndx_list);
++      filedata->symtab_shndx_list = next;
++    }
++
++  free (filedata->section_headers_groups);
++
++  if (filedata->section_groups)
++    {
++      size_t i;
++      struct group_list * g;
++      struct group_list * next;
++
++      for (i = 0; i < filedata->group_count; i++)
++	{
++	  for (g = filedata->section_groups [i].root; g != NULL; g = next)
++	    {
++	      next = g->next;
++	      free (g);
++	    }
++	}
++
++      free (filedata->section_groups);
++    }
++  memset (&filedata->section_headers, 0,
++	  sizeof (Filedata) - offsetof (Filedata, section_headers));
++}
++
++static void
++close_file (Filedata * filedata)
++{
++  if (filedata)
++    {
++      if (filedata->handle)
++	fclose (filedata->handle);
++      free (filedata);
++    }
++}
++
++void
++close_debug_file (void * data)
++{
++  free_filedata ((Filedata *) data);
++  close_file ((Filedata *) data);
++}
++
++static Filedata *
++open_file (const char * pathname, bool is_separate)
++{
++  struct stat  statbuf;
++  Filedata *   filedata = NULL;
++
++  if (stat (pathname, & statbuf) < 0
++      || ! S_ISREG (statbuf.st_mode))
++    goto fail;
++
++  filedata = calloc (1, sizeof * filedata);
++  if (filedata == NULL)
++    goto fail;
++
++  filedata->handle = fopen (pathname, "rb");
++  if (filedata->handle == NULL)
++    goto fail;
++
++  filedata->file_size = (bfd_size_type) statbuf.st_size;
++  filedata->file_name = pathname;
++  filedata->is_separate = is_separate;
++
++  if (! get_file_header (filedata))
++    goto fail;
++
++  if (!get_section_headers (filedata, false))
++    goto fail;
++
++  return filedata;
++
++ fail:
++  if (filedata)
++    {
++      if (filedata->handle)
++        fclose (filedata->handle);
++      free (filedata);
++    }
++  return NULL;
++}
++
++void *
++open_debug_file (const char * pathname)
++{
++  return open_file (pathname, true);
++}
++
++static void
++initialise_dump_sects (Filedata * filedata)
++{
++  /* Initialise the dump_sects array from the cmdline_dump_sects array.
++     Note we do this even if cmdline_dump_sects is empty because we
++     must make sure that the dump_sets array is zeroed out before each
++     object file is processed.  */
++  if (filedata->dump.num_dump_sects > cmdline.num_dump_sects)
++    memset (filedata->dump.dump_sects, 0,
++	    filedata->dump.num_dump_sects * sizeof (*filedata->dump.dump_sects));
++
++  if (cmdline.num_dump_sects > 0)
++    {
++      if (filedata->dump.num_dump_sects == 0)
++	/* A sneaky way of allocating the dump_sects array.  */
++	request_dump_bynumber (&filedata->dump, cmdline.num_dump_sects, 0);
++
++      assert (filedata->dump.num_dump_sects >= cmdline.num_dump_sects);
++      memcpy (filedata->dump.dump_sects, cmdline.dump_sects,
++	      cmdline.num_dump_sects * sizeof (*filedata->dump.dump_sects));
++    }
++}
++
++/* Process one ELF object file according to the command line options.
++   This file may actually be stored in an archive.  The file is
++   positioned at the start of the ELF object.  Returns TRUE if no
++   problems were encountered, FALSE otherwise.  */
++
++static bool
++process_object (Filedata * filedata)
++{
++  bool have_separate_files;
++  unsigned int i;
++  bool res;
++
++  if (! get_file_header (filedata))
++    {
++      error (_("%s: Failed to read file header\n"), filedata->file_name);
++      return false;
++    }
++
++  /* Initialise per file variables.  */
++  for (i = ARRAY_SIZE (filedata->version_info); i--;)
++    filedata->version_info[i] = 0;
++
++  for (i = ARRAY_SIZE (filedata->dynamic_info); i--;)
++    filedata->dynamic_info[i] = 0;
++  filedata->dynamic_info_DT_GNU_HASH = 0;
++  filedata->dynamic_info_DT_MIPS_XHASH = 0;
++
++  /* Process the file.  */
++  if (show_name)
++    printf (_("\nFile: %s\n"), filedata->file_name);
++
++  initialise_dump_sects (filedata);
++
++  /* There may be some extensions in the first section header.  Don't
++     bomb if we can't read it.  */
++  get_section_headers (filedata, true);
++
++  if (! process_file_header (filedata))
++    {
++      res = false;
++      goto out;
++    }
++
++  /* Throw away the single section header read above, so that we
++     re-read the entire set.  */
++  free (filedata->section_headers);
++  filedata->section_headers = NULL;
++
++  if (! process_section_headers (filedata))
++    {
++      /* Without loaded section headers we cannot process lots of things.  */
++      do_unwind = do_version = do_dump = do_arch = false;
++
++      if (! do_using_dynamic)
++	do_syms = do_dyn_syms = do_reloc = false;
++    }
++
++  if (! process_section_groups (filedata))
++    /* Without loaded section groups we cannot process unwind.  */
++    do_unwind = false;
++
++  process_program_headers (filedata);
++
++  res = process_dynamic_section (filedata);
++
++  if (! process_relocs (filedata))
++    res = false;
++
++  if (! process_unwind (filedata))
++    res = false;
++
++  if (! process_symbol_table (filedata))
++    res = false;
++
++  if (! process_lto_symbol_tables (filedata))
++    res = false;
++
++  if (! process_syminfo (filedata))
++    res = false;
++
++  if (! process_version_sections (filedata))
++    res = false;
++
++  if (filedata->file_header.e_shstrndx != SHN_UNDEF)
++    have_separate_files = load_separate_debug_files (filedata, filedata->file_name);
++  else
++    have_separate_files = false;
++
++  if (! process_section_contents (filedata))
++    res = false;
++
++  if (have_separate_files)
++    {
++      separate_info * d;
++
++      for (d = first_separate_info; d != NULL; d = d->next)
++	{
++	  initialise_dump_sects (d->handle);
++
++	  if (process_links && ! process_file_header (d->handle))
++	    res = false;
++	  else if (! process_section_headers (d->handle))
++	    res = false;
++	  else if (! process_section_contents (d->handle))
++	    res = false;
++	  else if (process_links)
++	    {
++	      if (! process_section_groups (d->handle))
++		res = false;
++	      process_program_headers (d->handle);
++	      if (! process_dynamic_section (d->handle))
++		res = false;
++	      if (! process_relocs (d->handle))
++		res = false;
++	      if (! process_unwind (d->handle))
++		res = false;
++	      if (! process_symbol_table (d->handle))
++		res = false;
++	      if (! process_lto_symbol_tables (d->handle))
++		res = false;
++	      if (! process_syminfo (d->handle))
++		res = false;
++	      if (! process_version_sections (d->handle))
++		res = false;
++	      if (! process_notes (d->handle))
++		res = false;
++	    }
++	}
++
++      /* The file handles are closed by the call to free_debug_memory() below.  */
++    }
++
++  if (! process_notes (filedata))
++    res = false;
++
++  if (! process_gnu_liblist (filedata))
++    res = false;
++
++  if (! process_arch_specific (filedata))
++    res = false;
++
++ out:
++  free_filedata (filedata);
++
++  free_debug_memory ();
++
++  return res;
++}
++
++/* Process an ELF archive.
++   On entry the file is positioned just after the ARMAG string.
++   Returns TRUE upon success, FALSE otherwise.  */
++
++static bool
++process_archive (Filedata * filedata, bool is_thin_archive)
++{
++  struct archive_info arch;
++  struct archive_info nested_arch;
++  size_t got;
++  bool ret = true;
++
++  show_name = true;
++
++  /* The ARCH structure is used to hold information about this archive.  */
++  arch.file_name = NULL;
++  arch.file = NULL;
++  arch.index_array = NULL;
++  arch.sym_table = NULL;
++  arch.longnames = NULL;
++
++  /* The NESTED_ARCH structure is used as a single-item cache of information
++     about a nested archive (when members of a thin archive reside within
++     another regular archive file).  */
++  nested_arch.file_name = NULL;
++  nested_arch.file = NULL;
++  nested_arch.index_array = NULL;
++  nested_arch.sym_table = NULL;
++  nested_arch.longnames = NULL;
++
++  if (setup_archive (&arch, filedata->file_name, filedata->handle,
++		     filedata->file_size, is_thin_archive,
++		     do_archive_index) != 0)
++    {
++      ret = false;
++      goto out;
++    }
++
++  if (do_archive_index)
++    {
++      if (arch.sym_table == NULL)
++	error (_("%s: unable to dump the index as none was found\n"),
++	       filedata->file_name);
++      else
++	{
++	  unsigned long i, l;
++	  unsigned long current_pos;
++
++	  printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
++		    "in the symbol table)\n"),
++		  filedata->file_name, (unsigned long) arch.index_num,
++		  arch.sym_size);
++
++	  current_pos = ftell (filedata->handle);
++
++	  for (i = l = 0; i < arch.index_num; i++)
++	    {
++	      if (i == 0
++		  || (i > 0 && arch.index_array[i] != arch.index_array[i - 1]))
++		{
++		  char * member_name
++		    = get_archive_member_name_at (&arch, arch.index_array[i],
++						  &nested_arch);
++
++		  if (member_name != NULL)
++		    {
++		      char * qualified_name
++			= make_qualified_name (&arch, &nested_arch,
++					       member_name);
++
++		      if (qualified_name != NULL)
++			{
++			  printf (_("Contents of binary %s at offset "),
++				  qualified_name);
++			  (void) print_vma (arch.index_array[i], PREFIX_HEX);
++			  putchar ('\n');
++			  free (qualified_name);
++			}
++		      free (member_name);
++		    }
++		}
++
++	      if (l >= arch.sym_size)
++		{
++		  error (_("%s: end of the symbol table reached "
++			   "before the end of the index\n"),
++			 filedata->file_name);
++		  ret = false;
++		  break;
++		}
++	      /* PR 17531: file: 0b6630b2.  */
++	      printf ("\t%.*s\n",
++		      (int) (arch.sym_size - l), arch.sym_table + l);
++	      l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
++	    }
++
++	  if (arch.uses_64bit_indices)
++	    l = (l + 7) & ~ 7;
++	  else
++	    l += l & 1;
++
++	  if (l < arch.sym_size)
++	    {
++	      error (ngettext ("%s: %ld byte remains in the symbol table, "
++			       "but without corresponding entries in "
++			       "the index table\n",
++			       "%s: %ld bytes remain in the symbol table, "
++			       "but without corresponding entries in "
++			       "the index table\n",
++			       arch.sym_size - l),
++		     filedata->file_name, arch.sym_size - l);
++	      ret = false;
++	    }
++
++	  if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
++	    {
++	      error (_("%s: failed to seek back to start of object files "
++		       "in the archive\n"),
++		     filedata->file_name);
++	      ret = false;
++	      goto out;
++	    }
++	}
++
++      if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
++	  && !do_segments && !do_header && !do_dump && !do_version
++	  && !do_histogram && !do_debugging && !do_arch && !do_notes
++	  && !do_section_groups && !do_dyn_syms)
++	{
++	  ret = true; /* Archive index only.  */
++	  goto out;
++	}
++    }
++
++  while (1)
++    {
++      char * name;
++      size_t namelen;
++      char * qualified_name;
++
++      /* Read the next archive header.  */
++      if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
++	{
++	  error (_("%s: failed to seek to next archive header\n"),
++		 arch.file_name);
++	  ret = false;
++	  break;
++	}
++      got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
++      if (got != sizeof arch.arhdr)
++	{
++	  if (got == 0)
++	    break;
++	  /* PR 24049 - we cannot use filedata->file_name as this will
++	     have already been freed.  */
++	  error (_("%s: failed to read archive header\n"), arch.file_name);
++
++	  ret = false;
++	  break;
++	}
++      if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
++	{
++	  error (_("%s: did not find a valid archive header\n"),
++		 arch.file_name);
++	  ret = false;
++	  break;
++	}
++
++      arch.next_arhdr_offset += sizeof arch.arhdr;
++
++      filedata->archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
++      if (filedata->archive_file_size & 01)
++	++filedata->archive_file_size;
++
++      name = get_archive_member_name (&arch, &nested_arch);
++      if (name == NULL)
++	{
++	  error (_("%s: bad archive file name\n"), arch.file_name);
++	  ret = false;
++	  break;
++	}
++      namelen = strlen (name);
++
++      qualified_name = make_qualified_name (&arch, &nested_arch, name);
++      if (qualified_name == NULL)
++	{
++	  error (_("%s: bad archive file name\n"), arch.file_name);
++	  free (name);
++	  ret = false;
++	  break;
++	}
++
++      if (is_thin_archive && arch.nested_member_origin == 0)
++	{
++	  /* This is a proxy for an external member of a thin archive.  */
++	  Filedata * member_filedata;
++	  char * member_file_name = adjust_relative_path
++	    (filedata->file_name, name, namelen);
++
++	  free (name);
++	  if (member_file_name == NULL)
++	    {
++	      free (qualified_name);
++	      ret = false;
++	      break;
++	    }
++
++	  member_filedata = open_file (member_file_name, false);
++	  if (member_filedata == NULL)
++	    {
++	      error (_("Input file '%s' is not readable.\n"), member_file_name);
++	      free (member_file_name);
++	      free (qualified_name);
++	      ret = false;
++	      break;
++	    }
++
++	  filedata->archive_file_offset = arch.nested_member_origin;
++	  member_filedata->file_name = qualified_name;
++
++	  /* The call to process_object() expects the file to be at the beginning.  */
++	  rewind (member_filedata->handle);
++
++	  if (! process_object (member_filedata))
++	    ret = false;
++
++	  close_file (member_filedata);
++	  free (member_file_name);
++	}
++      else if (is_thin_archive)
++	{
++	  Filedata thin_filedata;
++
++	  memset (&thin_filedata, 0, sizeof (thin_filedata));
++
++	  /* PR 15140: Allow for corrupt thin archives.  */
++	  if (nested_arch.file == NULL)
++	    {
++	      error (_("%s: contains corrupt thin archive: %s\n"),
++		     qualified_name, name);
++	      free (qualified_name);
++	      free (name);
++	      ret = false;
++	      break;
++	    }
++	  free (name);
++
++	  /* This is a proxy for a member of a nested archive.  */
++	  filedata->archive_file_offset
++	    = arch.nested_member_origin + sizeof arch.arhdr;
++
++	  /* The nested archive file will have been opened and setup by
++	     get_archive_member_name.  */
++	  if (fseek (nested_arch.file, filedata->archive_file_offset,
++		     SEEK_SET) != 0)
++	    {
++	      error (_("%s: failed to seek to archive member.\n"),
++		     nested_arch.file_name);
++	      free (qualified_name);
++	      ret = false;
++	      break;
++	    }
++
++	  thin_filedata.handle = nested_arch.file;
++	  thin_filedata.file_name = qualified_name;
++
++	  if (! process_object (& thin_filedata))
++	    ret = false;
++	}
++      else
++	{
++	  free (name);
++	  filedata->archive_file_offset = arch.next_arhdr_offset;
++	  filedata->file_name = qualified_name;
++	  if (! process_object (filedata))
++	    ret = false;
++	  arch.next_arhdr_offset += filedata->archive_file_size;
++	  /* Stop looping with "negative" archive_file_size.  */
++	  if (arch.next_arhdr_offset < filedata->archive_file_size)
++	    arch.next_arhdr_offset = -1ul;
++	}
++
++      free (qualified_name);
++    }
++
++ out:
++  if (nested_arch.file != NULL)
++    fclose (nested_arch.file);
++  release_archive (&nested_arch);
++  release_archive (&arch);
++
++  return ret;
++}
++
++static bool
++process_file (char * file_name)
++{
++  Filedata * filedata = NULL;
++  struct stat statbuf;
++  char armag[SARMAG];
++  bool ret = false;
++  char * name;
++  char * saved_program_name;
++
++  /* Overload program_name to include file_name.  Doing this means
++     that warning/error messages will positively identify the file
++     concerned even when multiple instances of readelf are running.  */
++  name = xmalloc (strlen (program_name) + strlen (file_name) + 3);
++  sprintf (name, "%s: %s", program_name, file_name);
++  saved_program_name = program_name;
++  program_name = name;
++
++  if (stat (file_name, &statbuf) < 0)
++    {
++      if (errno == ENOENT)
++	error (_("No such file\n"));
++      else
++	error (_("Could not locate file.  System error message: %s\n"),
++	       strerror (errno));
++      goto done;
++    }
++
++  if (! S_ISREG (statbuf.st_mode))
++    {
++      error (_("Not an ordinary file\n"));
++      goto done;
++    }
++
++  filedata = calloc (1, sizeof * filedata);
++  if (filedata == NULL)
++    {
++      error (_("Out of memory allocating file data structure\n"));
++      goto done;
++    }
++
++  filedata->file_name = file_name;
++  filedata->handle = fopen (file_name, "rb");
++  if (filedata->handle == NULL)
++    {
++      error (_("Not readable\n"));
++      goto done;
++    }
++
++  if (fread (armag, SARMAG, 1, filedata->handle) != 1)
++    {
++      error (_("Failed to read file's magic number\n"));
++      goto done;
++    }
++
++  filedata->file_size = (bfd_size_type) statbuf.st_size;
++  filedata->is_separate = false;
++
++  if (memcmp (armag, ARMAG, SARMAG) == 0)
++    {
++      if (process_archive (filedata, false))
++	ret = true;
++    }
++  else if (memcmp (armag, ARMAGT, SARMAG) == 0)
++    {
++      if (process_archive (filedata, true))
++	ret = true;
++    }
++  else
++    {
++      if (do_archive_index && !check_all)
++	error (_("Not an archive so its index cannot be displayed.\n"));
++
++      rewind (filedata->handle);
++      filedata->archive_file_size = filedata->archive_file_offset = 0;
++
++      if (process_object (filedata))
++	ret = true;
++    }
++
++ done:
++  if (filedata)
++    {
++      if (filedata->handle != NULL)
++	fclose (filedata->handle);
++      free (filedata->section_headers);
++      free (filedata->program_headers);
++      free (filedata->string_table);
++      free (filedata->dump.dump_sects);
++      free (filedata);
++    }
++  free (program_name);
++  program_name = saved_program_name;
++
++  free (ba_cache.strtab);
++  ba_cache.strtab = NULL;
++  free (ba_cache.symtab);
++  ba_cache.symtab = NULL;
++  ba_cache.filedata = NULL;
++
++  return ret;
++}
++
++#ifdef SUPPORT_DISASSEMBLY
++/* Needed by the i386 disassembler.  For extra credit, someone could
++   fix this so that we insert symbolic addresses here, esp for GOT/PLT
++   symbols.  */
++
++void
++print_address (unsigned int addr, FILE * outfile)
++{
++  fprintf (outfile,"0x%8.8x", addr);
++}
++
++/* Needed by the i386 disassembler.  */
++
++void
++db_task_printsym (unsigned int addr)
++{
++  print_address (addr, stderr);
++}
++#endif
++
++int
++main (int argc, char ** argv)
++{
++  int err;
++
++#ifdef HAVE_LC_MESSAGES
++  setlocale (LC_MESSAGES, "");
++#endif
++  setlocale (LC_CTYPE, "");
++  bindtextdomain (PACKAGE, LOCALEDIR);
++  textdomain (PACKAGE);
++
++  expandargv (&argc, &argv);
++
++  parse_args (& cmdline, argc, argv);
++
++  if (optind < (argc - 1))
++    /* When displaying information for more than one file,
++       prefix the information with the file name.  */
++    show_name = true;
++  else if (optind >= argc)
++    {
++      /* Ensure that the warning is always displayed.  */
++      do_checks = true;
++
++      warn (_("Nothing to do.\n"));
++      usage (stderr);
++    }
++
++  err = false;
++  while (optind < argc)
++    if (! process_file (argv[optind++]))
++      err = true;
++
++  free (cmdline.dump_sects);
++
++  free (dump_ctf_symtab_name);
++  free (dump_ctf_strtab_name);
++  free (dump_ctf_parent_name);
++
++  return err ? EXIT_FAILURE : EXIT_SUCCESS;
++}
+diff -rupN binutils.orig/binutils/strings.c binutils-2.37/binutils/strings.c
+--- binutils.orig/binutils/strings.c	2021-11-09 12:34:21.663802935 +0000
++++ binutils-2.37/binutils/strings.c	2021-11-09 12:34:46.293643851 +0000
+@@ -55,6 +55,19 @@
+    -T {bfdname}
+ 		Specify a non-default object file format.
+ 
++  --unicode={default|locale|invalid|hex|escape|highlight}
++  -u {d|l|i|x|e|h}
++                Determine how to handle UTF-8 unicode characters.  The default
++		is no special treatment.  All other versions of this option
++		only apply if the encoding is valid and enabling the option
++		implies --encoding=S.
++		The 'locale' option displays the characters according to the
++		current locale.  The 'invalid' option treats them as
++		non-string characters.  The 'hex' option displays them as hex
++		byte sequences.  The 'escape' option displays them as escape
++		sequences and the 'highlight' option displays them as
++		coloured escape sequences.
++
+   --output-separator=sep_string
+   -s sep_string	String used to separate parsed strings in output.
+ 		Default is newline.
+@@ -76,6 +89,22 @@
+ #include "safe-ctype.h"
+ #include "bucomm.h"
+ 
++#ifndef streq
++#define streq(a,b) (strcmp ((a),(b)) == 0)
++#endif
++
++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;
++
+ #define STRING_ISGRAPHIC(c) \
+       (   (c) >= 0 \
+        && (c) <= 255 \
+@@ -94,7 +123,7 @@ extern int errno;
+ static int address_radix;
+ 
+ /* Minimum length of sequence of graphic chars to trigger output.  */
+-static int string_min;
++static uint string_min;
+ 
+ /* Whether or not we include all whitespace as a graphic char.   */
+ static bool include_all_whitespace;
+@@ -121,21 +150,22 @@ static char *output_separator;
+ static struct option long_options[] =
+ {
+   {"all", no_argument, NULL, 'a'},
++  {"bytes", required_argument, NULL, 'n'},
+   {"data", no_argument, NULL, 'd'},
++  {"encoding", required_argument, NULL, 'e'},
++  {"help", no_argument, NULL, 'h'},
++  {"include-all-whitespace", no_argument, NULL, 'w'},
++  {"output-separator", required_argument, NULL, 's'},
+   {"print-file-name", no_argument, NULL, 'f'},
+-  {"bytes", required_argument, NULL, 'n'},
+   {"radix", required_argument, NULL, 't'},
+-  {"include-all-whitespace", no_argument, NULL, 'w'},
+-  {"encoding", required_argument, NULL, 'e'},
+   {"target", required_argument, NULL, 'T'},
+-  {"output-separator", required_argument, NULL, 's'},
+-  {"help", no_argument, NULL, 'h'},
++  {"unicode", required_argument, NULL, 'U'},
+   {"version", no_argument, NULL, 'v'},
+   {NULL, 0, NULL, 0}
+ };
+ 
+ static bool strings_file (char *);
+-static void print_strings (const char *, FILE *, file_ptr, int, int, char *);
++static void print_strings (const char *, FILE *, file_ptr, int, char *);
+ static void usage (FILE *, int) ATTRIBUTE_NORETURN;
+ 
+ int main (int, char **);
+@@ -171,7 +201,7 @@ main (int argc, char **argv)
+   encoding = 's';
+   output_separator = NULL;
+ 
+-  while ((optc = getopt_long (argc, argv, "adfhHn:wot:e:T:s:Vv0123456789",
++  while ((optc = getopt_long (argc, argv, "adfhHn:wot:e:T:s:U:Vv0123456789",
+ 			      long_options, (int *) 0)) != EOF)
+     {
+       switch (optc)
+@@ -244,6 +274,23 @@ main (int argc, char **argv)
+ 	  output_separator = optarg;
+           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 'V':
+ 	case 'v':
+ 	  print_version ("strings");
+@@ -258,6 +305,9 @@ main (int argc, char **argv)
+ 	}
+     }
+ 
++  if (unicode_display != unicode_default)
++    encoding = 'S';
++
+   if (numeric_opt != 0)
+     {
+       string_min = (int) strtoul (argv[numeric_opt - 1] + 1, &s, 0);
+@@ -293,14 +343,14 @@ main (int argc, char **argv)
+     {
+       datasection_only = false;
+       SET_BINARY (fileno (stdin));
+-      print_strings ("{standard input}", stdin, 0, 0, 0, (char *) NULL);
++      print_strings ("{standard input}", stdin, 0, 0, (char *) NULL);
+       files_given = true;
+     }
+   else
+     {
+       for (; optind < argc; ++optind)
+ 	{
+-	  if (strcmp (argv[optind], "-") == 0)
++	  if (streq (argv[optind], "-"))
+ 	    datasection_only = false;
+ 	  else
+ 	    {
+@@ -342,7 +392,7 @@ strings_a_section (bfd *abfd, asection *
+     }
+ 
+   *got_a_section = true;
+-  print_strings (filename, NULL, sect->filepos, 0, sectsize, (char *) mem);
++  print_strings (filename, NULL, sect->filepos, sectsize, (char *) mem);
+   free (mem);
+ }
+ 
+@@ -427,7 +477,7 @@ strings_file (char *file)
+ 	  return false;
+ 	}
+ 
+-      print_strings (file, stream, (file_ptr) 0, 0, 0, (char *) 0);
++      print_strings (file, stream, (file_ptr) 0, 0, (char *) NULL);
+ 
+       if (fclose (stream) == EOF)
+ 	{
+@@ -551,11 +601,627 @@ unget_part_char (long c, file_ptr *addre
+ 	}
+     }
+ }
++
++static void
++print_filename_and_address (const char * filename, file_ptr address)
++{
++  if (print_filenames)
++    printf ("%s: ", filename);
++
++  if (! print_addresses)
++    return;
++
++  switch (address_radix)
++    {
++    case 8:
++      if (sizeof (address) > sizeof (long))
++	{
++#ifndef __MSVCRT__
++	  printf ("%7llo ", (unsigned long long) address);
++#else
++	  printf ("%7I64o ", (unsigned long long) address);
++#endif
++	}
++      else
++	printf ("%7lo ", (unsigned long) address);
++      break;
++
++    case 10:
++      if (sizeof (address) > sizeof (long))
++	{
++#ifndef __MSVCRT__
++	  printf ("%7llu ", (unsigned long long) address);
++#else
++	  printf ("%7I64d ", (unsigned long long) address);
++#endif
++	}
++      else
++	printf ("%7ld ", (long) address);
++      break;
++
++    case 16:
++      if (sizeof (address) > sizeof (long))
++	{
++#ifndef __MSVCRT__
++	  printf ("%7llx ", (unsigned long long) address);
++#else
++	  printf ("%7I64x ", (unsigned long long) address);
++#endif
++	}
++      else
++	printf ("%7lx ", (unsigned long) address);
++      break;
++    }
++}
++
++/* Return non-zero if the bytes starting at BUFFER form a valid UTF-8 encoding.
++   If the encoding is valid then returns the number of bytes it uses.  */
++
++static unsigned int
++is_valid_utf8 (const unsigned char * buffer, unsigned long buflen)
++{
++  if (buffer[0] < 0xc0)
++    return 0;
++
++  if (buflen < 2)
++    return 0;
++
++  if ((buffer[1] & 0xc0) != 0x80)
++    return 0;
++
++  if ((buffer[0] & 0x20) == 0)
++    return 2;
++
++  if (buflen < 3)
++    return 0;
++
++  if ((buffer[2] & 0xc0) != 0x80)
++    return 0;
++  
++  if ((buffer[0] & 0x10) == 0)
++    return 3;
++
++  if (buflen < 4)
++    return 0;
++
++  if ((buffer[3] & 0xc0) != 0x80)
++    return 0;
++
++  return 4;
++}
++
++/* Display a UTF-8 encoded character in BUFFER according to the setting
++   of unicode_display.  The character is known to be valid.
++   Returns the number of bytes consumed.  */
++
++static uint
++display_utf8_char (const unsigned char * buffer)
++{
++  uint j;
++  uint utf8_len;
++
++  switch (buffer[0] & 0x30)
++    {
++    case 0x00:
++    case 0x10:
++      utf8_len = 2;
++      break;
++    case 0x20:
++      utf8_len = 3;
++      break;
++    default:
++      utf8_len = 4;
++    }
++      
++  switch (unicode_display)
++    {
++    default:
++      fprintf (stderr, "ICE: unexpected unicode display type\n");
++      break;
++
++    case unicode_escape:
++    case unicode_highlight:
++      if (unicode_display == unicode_highlight && isatty (1))
++	printf ("\x1B[31;47m"); /* Red.  */
++
++      switch (utf8_len)
++	{
++	case 2:
++	  printf ("\\u%02x%02x",
++		  ((buffer[0] & 0x1c) >> 2), 
++		  ((buffer[0] & 0x03) << 6) | (buffer[1] & 0x3f));
++	  break;
++
++	case 3:
++	  printf ("\\u%02x%02x",
++		  ((buffer[0] & 0x0f) << 4) | ((buffer[1] & 0x3c) >> 2),
++		  ((buffer[1] & 0x03) << 6) | ((buffer[2] & 0x3f)));
++	  break;
++
++	case 4:
++	  printf ("\\u%02x%02x%02x",
++		  ((buffer[0] & 0x07) << 6) | ((buffer[1] & 0x3c) >> 2),
++		  ((buffer[1] & 0x03) << 6) | ((buffer[2] & 0x3c) >> 2),
++		  ((buffer[2] & 0x03) << 6) | ((buffer[3] & 0x3f)));
++	  break;
++	default:
++	  /* URG.  */
++	  break;
++	}
++
++      if (unicode_display == unicode_highlight && isatty (1))
++	printf ("\033[0m"); /* Default colour.  */
++      break;
++
++    case unicode_hex:
++      putchar ('<');
++      printf ("0x");
++      for (j = 0; j < utf8_len; j++)
++	printf ("%02x", buffer [j]);
++      putchar ('>');
++      break;
++
++    case unicode_locale:
++      printf ("%.1s", buffer);
++      break;
++    }
++
++  return utf8_len;
++}
++
++/* Display strings in BUFFER.  Treat any UTF-8 encoded characters encountered
++   according to the setting of the unicode_display variable.  The buffer
++   contains BUFLEN bytes.
++
++   Display the characters as if they started at ADDRESS and are contained in
++   FILENAME.  */
++
++static void
++print_unicode_buffer (const char *            filename,
++		      file_ptr                address,
++		      const unsigned char *   buffer,
++		      unsigned long           buflen)
++{
++  /* Paranoia checks...  */
++  if (filename == NULL
++      || buffer == NULL
++      || unicode_display == unicode_default
++      || encoding != 'S'
++      || encoding_bytes != 1)
++    {
++      fprintf (stderr, "ICE: bad arguments to print_unicode_buffer\n");
++      return;
++    }
++
++  if (buflen == 0)
++    return;
++
++  /* We must only display strings that are at least string_min *characters*
++     long.  So we scan the buffer in two stages.  First we locate the start
++     of a potential string.  Then we walk along it until we have found
++     string_min characters.  Then we go back to the start point and start
++     displaying characters according to the unicode_display setting.  */
++
++  unsigned long start_point = 0;
++  unsigned long i = 0;
++  unsigned int char_len = 1;
++  unsigned int num_found = 0;
++
++  for (i = 0; i < buflen; i += char_len)
++    {
++      int c = buffer[i];
++
++      char_len = 1;
++
++      /* Find the first potential character of a string.  */
++      if (! STRING_ISGRAPHIC (c))
++	{
++	  num_found = 0;
++	  continue;
++	}
++
++      if (c > 126)
++	{
++	  if (c < 0xc0)
++	    {
++	      num_found = 0;
++	      continue;
++	    }
++
++	  if ((char_len = is_valid_utf8 (buffer + i, buflen - i)) == 0)
++	    {
++	      char_len = 1;
++	      num_found = 0;
++	      continue;
++	    }
++
++	  if (unicode_display == unicode_invalid)
++	    {
++	      /* We have found a valid UTF-8 character, but we treat it as non-graphic.  */
++	      num_found = 0;
++	      continue;
++	    }
++	}
++
++      if (num_found == 0)
++	/* We have found a potential starting point for a string.  */
++	start_point = i;
++
++      ++ num_found;
++
++      if (num_found >= string_min)
++	break;
++    }
++
++  if (num_found < string_min)
++    return;
++
++  print_filename_and_address (filename, address + start_point);
++  
++  /* We have found string_min characters.  Display them and any
++     more that follow.  */
++  for (i = start_point; i < buflen; i += char_len)
++    {
++      int c = buffer[i];
++
++      char_len = 1;
++
++      if (! STRING_ISGRAPHIC (c))
++	break;
++      else if (c < 127)
++	putchar (c);
++      else if (! is_valid_utf8 (buffer + i, buflen - i))
++	break;
++      else if (unicode_display == unicode_invalid)
++	break;
++      else
++	char_len = display_utf8_char (buffer + i);
++    }
++
++  if (output_separator)
++    fputs (output_separator, stdout);
++  else
++    putchar ('\n');
++
++  /* FIXME: Using tail recursion here is lazy programming...  */
++  print_unicode_buffer (filename, address + i, buffer + i, buflen - i);
++}
++
++static int
++get_unicode_byte (FILE * stream, unsigned char * putback, uint * num_putback, uint * num_read)
++{
++  if (* num_putback > 0)
++    {
++      * num_putback = * num_putback - 1;
++      return putback [* num_putback];
++    }
++
++  * num_read = * num_read + 1;
++
++#if defined(HAVE_GETC_UNLOCKED) && HAVE_DECL_GETC_UNLOCKED
++  return getc_unlocked (stream);
++#else
++  return getc (stream);
++#endif
++}
++
++/* Helper function for print_unicode_stream.  */
++
++static void
++print_unicode_stream_body (const char *     filename,
++			   file_ptr         address,
++			   FILE *           stream,
++			   unsigned char *  putback_buf,
++			   uint             num_putback,
++			   unsigned char *  print_buf)
++{
++  /* It would be nice if we could just read the stream into a buffer
++     and then process if with print_unicode_buffer.  But the input
++     might be huge or it might time-locked (eg stdin).  So instead
++     we go one byte at a time...  */
++
++  file_ptr start_point = 0;
++  uint num_read = 0;
++  uint num_chars = 0;
++  uint num_print = 0;
++  int c;
++
++  /* Find a series of string_min characters.  Put them into print_buf.  */
++  do
++    {
++      if (num_chars >= string_min)
++	break;
++
++      c = get_unicode_byte (stream, putback_buf, & num_putback, & num_read);
++      if (c == EOF)
++	break;
++
++      if (! STRING_ISGRAPHIC (c))
++	{
++	  num_chars = num_print = 0;
++	  continue;
++	}
++
++      if (num_chars == 0)
++	start_point = num_read - 1;
++
++      if (c < 127)
++	{
++	  print_buf[num_print] = c;
++	  num_chars ++;
++	  num_print ++;
++	  continue;
++	}
++
++      if (c < 0xc0)
++	{
++	  num_chars = num_print = 0;
++	  continue;
++	}
++
++      /* We *might* have a UTF-8 sequence.  Time to start peeking.  */
++      char utf8[4];
++
++      utf8[0] = c;
++      c = get_unicode_byte (stream, putback_buf, & num_putback, & num_read);
++      if (c == EOF)
++	break;
++      utf8[1] = c;
++
++      if ((utf8[1] & 0xc0) != 0x80)
++	{
++	  /* Invalid UTF-8.  */
++	  putback_buf[num_putback++] = utf8[1];
++	  num_chars = num_print = 0;
++	  continue;
++	}
++      else if ((utf8[0] & 0x20) == 0)
++	{
++	  /* A valid 2-byte UTF-8 encoding.  */
++	  if (unicode_display == unicode_invalid)
++	    {
++	      putback_buf[num_putback++] = utf8[1];
++	      num_chars = num_print = 0;
++	    }
++	  else
++	    {
++	      print_buf[num_print ++] = utf8[0];
++	      print_buf[num_print ++] = utf8[1];
++	      num_chars ++;
++	    }
++	  continue;
++	}
++
++      c = get_unicode_byte (stream, putback_buf, & num_putback, & num_read);
++      if (c == EOF)
++	break;
++      utf8[2] = c;
++
++      if ((utf8[2] & 0xc0) != 0x80)
++	{
++	  /* Invalid UTF-8.  */
++	  putback_buf[num_putback++] = utf8[2];
++	  putback_buf[num_putback++] = utf8[1];
++	  num_chars = num_print = 0;
++	  continue;
++	}
++      else if ((utf8[0] & 0x10) == 0)
++	{
++	  /* A valid 3-byte UTF-8 encoding.  */
++	  if (unicode_display == unicode_invalid)
++	    {
++	      putback_buf[num_putback++] = utf8[2];
++	      putback_buf[num_putback++] = utf8[1];
++	      num_chars = num_print = 0;
++	    }
++	  else
++	    {
++	      print_buf[num_print ++] = utf8[0];
++	      print_buf[num_print ++] = utf8[1];
++	      print_buf[num_print ++] = utf8[2];
++	      num_chars ++;
++	    }
++	  continue;
++	}
++
++      c = get_unicode_byte (stream, putback_buf, & num_putback, & num_read);
++      if (c == EOF)
++	break;
++      utf8[3] = c;
++
++      if ((utf8[3] & 0xc0) != 0x80)
++	{
++	  /* Invalid UTF-8.  */
++	  putback_buf[num_putback++] = utf8[3];
++	  putback_buf[num_putback++] = utf8[2];
++	  putback_buf[num_putback++] = utf8[1];
++	  num_chars = num_print = 0;
++	}
++      /* We have a valid 4-byte UTF-8 encoding.  */
++      else if (unicode_display == unicode_invalid)
++	{
++	  putback_buf[num_putback++] = utf8[3];
++	  putback_buf[num_putback++] = utf8[1];
++	  putback_buf[num_putback++] = utf8[2];
++	  num_chars = num_print = 0;
++	}
++      else
++	{
++	  print_buf[num_print ++] = utf8[0];
++	  print_buf[num_print ++] = utf8[1];
++	  print_buf[num_print ++] = utf8[2];
++	  print_buf[num_print ++] = utf8[3];
++	  num_chars ++;
++	}
++    }
++  while (1);
++
++  if (num_chars >= string_min)
++    {
++      /* We know that we have string_min valid characters in print_buf,
++	 and there may be more to come in the stream.  Start displaying
++	 them.  */
++
++      print_filename_and_address (filename, address + start_point);
++
++      uint i;
++      for (i = 0; i < num_print;)
++	{
++	  if (print_buf[i] < 127)
++	    putchar (print_buf[i++]);
++	  else
++	    i += display_utf8_char (print_buf + i);
++	}
++
++      /* OK so now we have to start read unchecked bytes.  */
++
++        /* Find a series of string_min characters.  Put them into print_buf.  */
++      do
++	{
++	  c = get_unicode_byte (stream, putback_buf, & num_putback, & num_read);
++	  if (c == EOF)
++	    break;
++
++	  if (! STRING_ISGRAPHIC (c))
++	    break;
++
++	  if (c < 127)
++	    {
++	      putchar (c);
++	      continue;
++	    }
++
++	  if (c < 0xc0)
++	    break;
++
++	  /* We *might* have a UTF-8 sequence.  Time to start peeking.  */
++	  unsigned char utf8[4];
++
++	  utf8[0] = c;
++	  c = get_unicode_byte (stream, putback_buf, & num_putback, & num_read);
++	  if (c == EOF)
++	    break;
++	  utf8[1] = c;
++
++	  if ((utf8[1] & 0xc0) != 0x80)
++	    {
++	      /* Invalid UTF-8.  */
++	      putback_buf[num_putback++] = utf8[1];
++	      break;
++	    }
++	  else if ((utf8[0] & 0x20) == 0)
++	    {
++	      /* Valid 2-byte UTF-8.  */
++	      if (unicode_display == unicode_invalid)
++		{
++		  putback_buf[num_putback++] = utf8[1];
++		  break;
++		}
++	      else
++		{
++		  (void) display_utf8_char (utf8);
++		  continue;
++		}
++	    }
++
++	  c = get_unicode_byte (stream, putback_buf, & num_putback, & num_read);
++	  if (c == EOF)
++	    break;
++	  utf8[2] = c;
++
++	  if ((utf8[2] & 0xc0) != 0x80)
++	    {
++	      /* Invalid UTF-8.  */
++	      putback_buf[num_putback++] = utf8[2];
++	      putback_buf[num_putback++] = utf8[1];
++	      break;
++	    }
++	  else if ((utf8[0] & 0x10) == 0)
++	    {
++	      /* Valid 3-byte UTF-8.  */
++	      if (unicode_display == unicode_invalid)
++		{
++		  putback_buf[num_putback++] = utf8[2];
++		  putback_buf[num_putback++] = utf8[1];
++		  break;
++		}
++	      else
++		{
++		  (void) display_utf8_char (utf8);
++		  continue;
++		}
++	    }
++
++	  c = get_unicode_byte (stream, putback_buf, & num_putback, & num_read);
++	  if (c == EOF)
++	    break;
++	  utf8[3] = c;
++
++	  if ((utf8[3] & 0xc0) != 0x80)
++	    {
++	      /* Invalid UTF-8.  */
++	      putback_buf[num_putback++] = utf8[3];
++	      putback_buf[num_putback++] = utf8[2];
++	      putback_buf[num_putback++] = utf8[1];
++	      break;
++	    }
++	  else if (unicode_display == unicode_invalid)
++	    {
++	      putback_buf[num_putback++] = utf8[3];
++	      putback_buf[num_putback++] = utf8[2];
++	      putback_buf[num_putback++] = utf8[1];
++	      break;
++	    }
++	  else
++	    /* A valid 4-byte UTF-8 encoding.  */
++	    (void) display_utf8_char (utf8);
++	}
++      while (1);
++
++      if (output_separator)
++	fputs (output_separator, stdout);
++      else
++	putchar ('\n');
++    }
++
++  if (c != EOF)
++    /* FIXME: Using tail recursion here is lazy, but it works.  */
++    print_unicode_stream_body (filename, address + num_read, stream, putback_buf, num_putback, print_buf);
++}
++
++/* Display strings read in from STREAM.  Treat any UTF-8 encoded characters
++   encountered according to the setting of the unicode_display variable.
++   The stream is positioned at ADDRESS and is attached to FILENAME.  */
++
++static void
++print_unicode_stream (const char * filename,
++		      file_ptr     address,
++		      FILE *       stream)
++{
++  /* Paranoia checks...  */
++  if (filename == NULL
++      || stream == NULL
++      || unicode_display == unicode_default
++      || encoding != 'S'
++      || encoding_bytes != 1)
++    {
++      fprintf (stderr, "ICE: bad arguments to print_unicode_stream\n");
++      return;
++    }
++
++  /* Allocate space for string_min 4-byte utf-8 characters.  */
++  unsigned char * print_buf = xmalloc ((4 * string_min) + 1);
++  /* We should never have to put back more than 4 bytes.  */
++  unsigned char putback_buf[5];
++  uint num_putback = 0;
++
++  print_unicode_stream_body (filename, address, stream, putback_buf, num_putback, print_buf);
++  free (print_buf);
++}
+ 
+ /* Find the strings in file FILENAME, read from STREAM.
+    Assume that STREAM is positioned so that the next byte read
+    is at address ADDRESS in the file.
+-   Stop reading at address STOP_POINT in the file, if nonzero.
+ 
+    If STREAM is NULL, do not read from it.
+    The caller can supply a buffer of characters
+@@ -566,20 +1232,29 @@ unget_part_char (long c, file_ptr *addre
+ 
+ static void
+ print_strings (const char *filename, FILE *stream, file_ptr address,
+-	       int stop_point, int magiccount, char *magic)
++	       int magiccount, char *magic)
+ {
++  if (unicode_display != unicode_default)
++    {
++      if (magic != NULL)
++	print_unicode_buffer (filename, address,
++			      (const unsigned char *) magic, magiccount);
++
++      if (stream != NULL)
++	print_unicode_stream (filename, address, stream);
++      return;
++    }
++
+   char *buf = (char *) xmalloc (sizeof (char) * (string_min + 1));
+ 
+   while (1)
+     {
+       file_ptr start;
+-      int i;
++      uint i;
+       long c;
+ 
+       /* See if the next `string_min' chars are all graphic chars.  */
+     tryline:
+-      if (stop_point && address >= stop_point)
+-	break;
+       start = address;
+       for (i = 0; i < string_min; i++)
+ 	{
+@@ -601,51 +1276,7 @@ print_strings (const char *filename, FIL
+ 
+       /* We found a run of `string_min' graphic characters.  Print up
+ 	 to the next non-graphic character.  */
+-
+-      if (print_filenames)
+-	printf ("%s: ", filename);
+-      if (print_addresses)
+-	switch (address_radix)
+-	  {
+-	  case 8:
+-	    if (sizeof (start) > sizeof (long))
+-	      {
+-#ifndef __MSVCRT__
+-		printf ("%7llo ", (unsigned long long) start);
+-#else
+-		printf ("%7I64o ", (unsigned long long) start);
+-#endif
+-	      }
+-	    else
+-	      printf ("%7lo ", (unsigned long) start);
+-	    break;
+-
+-	  case 10:
+-	    if (sizeof (start) > sizeof (long))
+-	      {
+-#ifndef __MSVCRT__
+-		printf ("%7llu ", (unsigned long long) start);
+-#else
+-		printf ("%7I64d ", (unsigned long long) start);
+-#endif
+-	      }
+-	    else
+-	      printf ("%7ld ", (long) start);
+-	    break;
+-
+-	  case 16:
+-	    if (sizeof (start) > sizeof (long))
+-	      {
+-#ifndef __MSVCRT__
+-		printf ("%7llx ", (unsigned long long) start);
+-#else
+-		printf ("%7I64x ", (unsigned long long) start);
+-#endif
+-	      }
+-	    else
+-	      printf ("%7lx ", (unsigned long) start);
+-	    break;
+-	  }
++      print_filename_and_address (filename, start);
+ 
+       buf[i] = '\0';
+       fputs (buf, stdout);
+@@ -697,6 +1328,8 @@ usage (FILE *stream, int status)
+   -T --target=<BFDNAME>     Specify the binary file format\n\
+   -e --encoding={s,S,b,l,B,L} Select character size and endianness:\n\
+                             s = 7-bit, S = 8-bit, {b,l} = 16-bit, {B,L} = 32-bit\n\
++  --unicode={default|show|invalid|hex|escape|highlight}\n\
++  -u {d|s|i|x|e|h}          Specify how to treat UTF-8 encoded unicode characters\n\
+   -s --output-separator=<string> String used to separate strings in output.\n\
+   @<file>                   Read options from <file>\n\
+   -h --help                 Display this information\n\
+diff -rupN binutils.orig/binutils/testsuite/binutils-all/nm.hex.unicode binutils-2.37/binutils/testsuite/binutils-all/nm.hex.unicode
+--- binutils.orig/binutils/testsuite/binutils-all/nm.hex.unicode	1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.37/binutils/testsuite/binutils-all/nm.hex.unicode	2021-11-09 12:36:58.045780720 +0000
+@@ -0,0 +1,3 @@
++#...
++.*he<0xe280ae>oll<0xe280ac>
++#pass
+diff -rupN binutils.orig/binutils/testsuite/binutils-all/objdump.highlight.unicode binutils-2.37/binutils/testsuite/binutils-all/objdump.highlight.unicode
+--- binutils.orig/binutils/testsuite/binutils-all/objdump.highlight.unicode	1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.37/binutils/testsuite/binutils-all/objdump.highlight.unicode	2021-11-09 12:37:28.046580043 +0000
+@@ -0,0 +1,3 @@
++#...
++.*he\\u202eoll\\u202c
++#pass
+diff -rupN binutils.orig/binutils/testsuite/binutils-all/readelf.invalid.unicode binutils-2.37/binutils/testsuite/binutils-all/readelf.invalid.unicode
+--- binutils.orig/binutils/testsuite/binutils-all/readelf.invalid.unicode	1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.37/binutils/testsuite/binutils-all/readelf.invalid.unicode	2021-11-09 12:37:15.069666851 +0000
+@@ -0,0 +1,3 @@
++#...
++.*he\{0xe280ae\}oll\{0xe280ac\}
++#pass
+diff -rupN binutils.orig/binutils/testsuite/binutils-all/strings.escape.unicode binutils-2.37/binutils/testsuite/binutils-all/strings.escape.unicode
+--- binutils.orig/binutils/testsuite/binutils-all/strings.escape.unicode	1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.37/binutils/testsuite/binutils-all/strings.escape.unicode	2021-11-09 12:36:46.692856666 +0000
+@@ -0,0 +1,3 @@
++#...
++he\\u202eoll\\u202c
++#pass
+diff -rupN binutils.orig/binutils/testsuite/binutils-all/trick-hello.s binutils-2.37/binutils/testsuite/binutils-all/trick-hello.s
+--- binutils.orig/binutils/testsuite/binutils-all/trick-hello.s	1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.37/binutils/testsuite/binutils-all/trick-hello.s	2021-11-09 12:35:31.566351425 +0000
+@@ -0,0 +1,33 @@
++	.file	"trick-hello.c"
++	.text
++	.section	.rodata
++.LC0:
++	.string	"hah, gotcha!"
++	.text
++	.globl	he‮oll‬
++	.type	he‮oll‬, %function
++he‮oll‬:
++.LFB0:
++	nop
++.LFE0:
++	.size	he‮oll‬, .-he‮oll‬
++	.section	.rodata
++.LC1:
++	.string	"Hello world"
++	.text
++	.globl	hello
++	.type	hello, %function
++hello:
++.LFB1:
++	nop
++.LFE1:
++	.size	hello, .-hello
++	.globl	main
++	.type	main, %function
++main:
++.LFB2:
++	nop
++.LFE2:
++	.size	main, .-main
++	.ident	"GCC: (GNU) 11.2.1 20210728 (Red Hat 11.2.1-1)"
++
+diff -rupN binutils.orig/binutils/testsuite/binutils-all/unicode.exp binutils-2.37/binutils/testsuite/binutils-all/unicode.exp
+--- binutils.orig/binutils/testsuite/binutils-all/unicode.exp	1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.37/binutils/testsuite/binutils-all/unicode.exp	2021-11-09 12:35:23.631402678 +0000
+@@ -0,0 +1,71 @@
++#   Copyright (C) 2021 Free Software Foundation, Inc.
++
++# 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 of the License, 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, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
++
++# Written by Nick Clifton <nickc@redhat.com>
++
++proc unicode_test { program options binary_file regexp_file } {
++
++    global srcdir
++    global subdir
++
++    set testname "unicode $program $options [file rootname [file tail $binary_file]]"
++
++    send_log "exec $program $options $binary_file > prog.out\n"
++    set got [remote_exec host "$program $options $binary_file" "" "/dev/null" "prog.out"]
++
++    if { [lindex $got 0] != 0 } then {
++	fail "$testname (reason: execution failed)"
++	send_log $got
++	send_log "\n"
++	return
++    }
++
++    if { ![string match "" [lindex $got 1]] } then {
++	fail "$testname (reason: error output)"
++	send_log $got
++	send_log "\n"
++	return
++    }
++
++    if { [regexp_diff prog.out $srcdir/$subdir/$regexp_file] } then {
++	send_log [file_contents prog.out]
++	send_log "\n"
++	fail $testname
++	return
++    }
++
++    pass $testname
++}
++
++# Assemble the test file.
++if {![binutils_assemble $srcdir/$subdir/trick-hello.s tmpdir/trick-hello.o]} then {
++    unsupported "unicode tests (failed to assemble test file)"
++} else {
++    if ![is_remote host] {
++	set tempfile tmpdir/trick-hello.o
++    } else {
++	set tempfile [remote_download host tmpdir/trick-hello.o]
++    }
++
++    global NM STRINGS OBJDUMP READELF
++    unicode_test $NM      {--unicode=hex}    $tempfile nm.hex.unicode
++    unicode_test $STRINGS {--unicode=escape} $tempfile strings.escape.unicode
++    unicode_test $OBJDUMP {-tUh}             $tempfile objdump.highlight.unicode
++
++    if [is_elf_format] {
++	unicode_test $READELF {-sUi}         $tempfile readelf.invalid.unicode
++    }
++}