binutils/readelf.c

   1 /* readelf.c -- display contents of an ELF format file
   2    Copyright (C) 1998-2019 Free Software Foundation, Inc.
   3
   4    Originally developed by Eric Youngdale <eric@andante.jic.com>
   5    Modifications by Nick Clifton <nickc@redhat.com>
   6
   7    This file is part of GNU Binutils.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  22    02110-1301, USA.  */
  23 \f
  24 /* The difference between readelf and objdump:
  25
  26   Both programs are capable of displaying the contents of ELF format files,
  27   so why does the binutils project have two file dumpers ?
  28
  29   The reason is that objdump sees an ELF file through a BFD filter of the
  30   world; if BFD has a bug where, say, it disagrees about a machine constant
  31   in e_flags, then the odds are good that it will remain internally
  32   consistent.  The linker sees it the BFD way, objdump sees it the BFD way,
  33   GAS sees it the BFD way.  There was need for a tool to go find out what
  34   the file actually says.
  35
  36   This is why the readelf program does not link against the BFD library - it
  37   exists as an independent program to help verify the correct working of BFD.
  38
  39   There is also the case that readelf can provide more information about an
  40   ELF file than is provided by objdump.  In particular it can display DWARF
  41   debugging information which (at the moment) objdump cannot.  */
  42 \f
  43 #include "sysdep.h"
  44 #include <assert.h>
  45 #include <time.h>
  46 #include <zlib.h>
  47 #ifdef HAVE_WCHAR_H
  48 #include <wchar.h>
  49 #endif
  50
  51 #if __GNUC__ >= 2
  52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
  53    as this will allow us to read in and parse 64bit and 32bit ELF files.
  54    Only do this if we believe that the compiler can support a 64 bit
  55    data type.  For now we only rely on GCC being able to do this.  */
  56 #define BFD64
  57 #endif
  58
  59 #include "bfd.h"
  60 #include "bucomm.h"
  61 #include "elfcomm.h"
  62 #include "dwarf.h"
  63 #include "ctf-api.h"
  64
  65 #include "elf/common.h"
  66 #include "elf/external.h"
  67 #include "elf/internal.h"
  68
  69
  70 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
  71    we can obtain the H8 reloc numbers.  We need these for the
  72    get_reloc_size() function.  We include h8.h again after defining
  73    RELOC_MACROS_GEN_FUNC so that we get the naming function as well.  */
  74
  75 #include "elf/h8.h"
  76 #undef _ELF_H8_H
  77
  78 /* Undo the effects of #including reloc-macros.h.  */
  79
  80 #undef START_RELOC_NUMBERS
  81 #undef RELOC_NUMBER
  82 #undef FAKE_RELOC
  83 #undef EMPTY_RELOC
  84 #undef END_RELOC_NUMBERS
  85 #undef _RELOC_MACROS_H
  86
  87 /* The following headers use the elf/reloc-macros.h file to
  88    automatically generate relocation recognition functions
  89    such as elf_mips_reloc_type()  */
  90
  91 #define RELOC_MACROS_GEN_FUNC
  92
  93 #include "elf/aarch64.h"
  94 #include "elf/alpha.h"
  95 #include "elf/arc.h"
  96 #include "elf/arm.h"
  97 #include "elf/avr.h"
  98 #include "elf/bfin.h"
  99 #include "elf/cr16.h"
 100 #include "elf/cris.h"
 101 #include "elf/crx.h"
 102 #include "elf/csky.h"
 103 #include "elf/d10v.h"
 104 #include "elf/d30v.h"
 105 #include "elf/dlx.h"
 106 #include "elf/bpf.h"
 107 #include "elf/epiphany.h"
 108 #include "elf/fr30.h"
 109 #include "elf/frv.h"
 110 #include "elf/ft32.h"
 111 #include "elf/h8.h"
 112 #include "elf/hppa.h"
 113 #include "elf/i386.h"
 114 #include "elf/i370.h"
 115 #include "elf/i860.h"
 116 #include "elf/i960.h"
 117 #include "elf/ia64.h"
 118 #include "elf/ip2k.h"
 119 #include "elf/lm32.h"
 120 #include "elf/iq2000.h"
 121 #include "elf/m32c.h"
 122 #include "elf/m32r.h"
 123 #include "elf/m68k.h"
 124 #include "elf/m68hc11.h"
 125 #include "elf/s12z.h"
 126 #include "elf/mcore.h"
 127 #include "elf/mep.h"
 128 #include "elf/metag.h"
 129 #include "elf/microblaze.h"
 130 #include "elf/mips.h"
 131 #include "elf/mmix.h"
 132 #include "elf/mn10200.h"
 133 #include "elf/mn10300.h"
 134 #include "elf/moxie.h"
 135 #include "elf/mt.h"
 136 #include "elf/msp430.h"
 137 #include "elf/nds32.h"
 138 #include "elf/nfp.h"
 139 #include "elf/nios2.h"
 140 #include "elf/or1k.h"
 141 #include "elf/pj.h"
 142 #include "elf/ppc.h"
 143 #include "elf/ppc64.h"
 144 #include "elf/pru.h"
 145 #include "elf/riscv.h"
 146 #include "elf/rl78.h"
 147 #include "elf/rx.h"
 148 #include "elf/s390.h"
 149 #include "elf/score.h"
 150 #include "elf/sh.h"
 151 #include "elf/sparc.h"
 152 #include "elf/spu.h"
 153 #include "elf/tic6x.h"
 154 #include "elf/tilegx.h"
 155 #include "elf/tilepro.h"
 156 #include "elf/v850.h"
 157 #include "elf/vax.h"
 158 #include "elf/visium.h"
 159 #include "elf/wasm32.h"
 160 #include "elf/x86-64.h"
 161 #include "elf/xc16x.h"
 162 #include "elf/xgate.h"
 163 #include "elf/xstormy16.h"
 164 #include "elf/xtensa.h"
 165
 166 #include "getopt.h"
 167 #include "libiberty.h"
 168 #include "safe-ctype.h"
 169 #include "filenames.h"
 170
 171 #ifndef offsetof
 172 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
 173 #endif
 174
 175 typedef struct elf_section_list
 176 {
 177   Elf_Internal_Shdr *        hdr;
 178   struct elf_section_list *  next;
 179 } elf_section_list;
 180
 181 /* Flag bits indicating particular types of dump.  */
 182 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
 183 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
 184 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
 185 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
 186 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
 187 #define CTF_DUMP        (1 << 5)        /* The --ctf command line switch.  */
 188
 189 typedef unsigned char dump_type;
 190
 191 /* A linked list of the section names for which dumps were requested.  */
 192 struct dump_list_entry
 193 {
 194   char *                    name;
 195   dump_type                 type;
 196   struct dump_list_entry *  next;
 197 };
 198
 199 typedef struct filedata
 200 {
 201   const char *         file_name;
 202   FILE *               handle;
 203   bfd_size_type        file_size;
 204   Elf_Internal_Ehdr    file_header;
 205   Elf_Internal_Shdr *  section_headers;
 206   Elf_Internal_Phdr *  program_headers;
 207   char *               string_table;
 208   unsigned long        string_table_length;
 209   /* A dynamic array of flags indicating for which sections a dump of
 210      some kind has been requested.  It is reset on a per-object file
 211      basis and then initialised from the cmdline_dump_sects array,
 212      the results of interpreting the -w switch, and the
 213      dump_sects_byname list.  */
 214   dump_type *          dump_sects;
 215   unsigned int         num_dump_sects;
 216 } Filedata;
 217
 218 char * program_name = "readelf";
 219
 220 static unsigned long archive_file_offset;
 221 static unsigned long archive_file_size;
 222 static unsigned long dynamic_addr;
 223 static bfd_size_type dynamic_size;
 224 static size_t dynamic_nent;
 225 static char * dynamic_strings;
 226 static unsigned long dynamic_strings_length;
 227 static unsigned long num_dynamic_syms;
 228 static Elf_Internal_Sym * dynamic_symbols;
 229 static Elf_Internal_Syminfo * dynamic_syminfo;
 230 static unsigned long dynamic_syminfo_offset;
 231 static unsigned int dynamic_syminfo_nent;
 232 static char program_interpreter[PATH_MAX];
 233 static bfd_vma dynamic_info[DT_ENCODING];
 234 static bfd_vma dynamic_info_DT_GNU_HASH;
 235 static bfd_vma dynamic_info_DT_MIPS_XHASH;
 236 static bfd_vma version_info[16];
 237 static Elf_Internal_Dyn *  dynamic_section;
 238 static elf_section_list * symtab_shndx_list;
 239 static bfd_boolean show_name = FALSE;
 240 static bfd_boolean do_dynamic = FALSE;
 241 static bfd_boolean do_syms = FALSE;
 242 static bfd_boolean do_dyn_syms = FALSE;
 243 static bfd_boolean do_reloc = FALSE;
 244 static bfd_boolean do_sections = FALSE;
 245 static bfd_boolean do_section_groups = FALSE;
 246 static bfd_boolean do_section_details = FALSE;
 247 static bfd_boolean do_segments = FALSE;
 248 static bfd_boolean do_unwind = FALSE;
 249 static bfd_boolean do_using_dynamic = FALSE;
 250 static bfd_boolean do_header = FALSE;
 251 static bfd_boolean do_dump = FALSE;
 252 static bfd_boolean do_version = FALSE;
 253 static bfd_boolean do_histogram = FALSE;
 254 static bfd_boolean do_debugging = FALSE;
 255 static bfd_boolean do_ctf = FALSE;
 256 static bfd_boolean do_arch = FALSE;
 257 static bfd_boolean do_notes = FALSE;
 258 static bfd_boolean do_archive_index = FALSE;
 259 static bfd_boolean is_32bit_elf = FALSE;
 260 static bfd_boolean decompress_dumps = FALSE;
 261
 262 static char *dump_ctf_parent_name;
 263 static char *dump_ctf_symtab_name;
 264 static char *dump_ctf_strtab_name;
 265
 266 struct group_list
 267 {
 268   struct group_list *  next;
 269   unsigned int         section_index;
 270 };
 271
 272 struct group
 273 {
 274   struct group_list *  root;
 275   unsigned int         group_index;
 276 };
 277
 278 static size_t           group_count;
 279 static struct group *   section_groups;
 280 static struct group **  section_headers_groups;
 281
 282 /* A dynamic array of flags indicating for which sections a dump
 283    has been requested via command line switches.  */
 284 static Filedata         cmdline;
 285
 286 static struct dump_list_entry * dump_sects_byname;
 287
 288 /* How to print a vma value.  */
 289 typedef enum print_mode
 290 {
 291   HEX,
 292   DEC,
 293   DEC_5,
 294   UNSIGNED,
 295   PREFIX_HEX,
 296   FULL_HEX,
 297   LONG_HEX
 298 }
 299 print_mode;
 300
 301 /* Versioned symbol info.  */
 302 enum versioned_symbol_info
 303 {
 304   symbol_undefined,
 305   symbol_hidden,
 306   symbol_public
 307 };
 308
 309 static const char * get_symbol_version_string
 310   (Filedata *, bfd_boolean, const char *, unsigned long, unsigned,
 311    Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
 312
 313 #define UNKNOWN -1
 314
 315 #define SECTION_NAME(X)                                         \
 316   ((X) == NULL ? _("<none>")                                    \
 317    : filedata->string_table == NULL ? _("<no-strings>")         \
 318    : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>")    \
 319   : filedata->string_table + (X)->sh_name))
 320
 321 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 322
 323 #define GET_ELF_SYMBOLS(file, section, sym_count)                       \
 324   (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count)      \
 325    : get_64bit_elf_symbols (file, section, sym_count))
 326
 327 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
 328 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 329    already been called and verified that the string exists.  */
 330 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
 331
 332 #define REMOVE_ARCH_BITS(ADDR)                  \
 333   do                                            \
 334     {                                           \
 335       if (filedata->file_header.e_machine == EM_ARM)    \
 336         (ADDR) &= ~1;                           \
 337     }                                           \
 338   while (0)
 339
 340 /* Get the correct GNU hash section name.  */
 341 #define GNU_HASH_SECTION_NAME                   \
 342   dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
 343 \f
 344 /* Print a BFD_VMA to an internal buffer, for use in error messages.
 345    BFD_FMA_FMT can't be used in translated strings.  */
 346
 347 static const char *
 348 bfd_vmatoa (char *fmtch, bfd_vma value)
 349 {
 350   /* bfd_vmatoa is used more then once in a printf call for output.
 351      Cycle through an array of buffers.  */
 352   static int buf_pos = 0;
 353   static struct bfd_vmatoa_buf
 354   {
 355     char place[64];
 356   } buf[4];
 357   char *ret;
 358   char fmt[32];
 359
 360   ret = buf[buf_pos++].place;
 361   buf_pos %= ARRAY_SIZE (buf);
 362
 363   sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch);
 364   snprintf (ret, sizeof (buf[0].place), fmt, value);
 365   return ret;
 366 }
 367
 368 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
 369    OFFSET + the offset of the current archive member, if we are examining an
 370    archive.  Put the retrieved data into VAR, if it is not NULL.  Otherwise
 371    allocate a buffer using malloc and fill that.  In either case return the
 372    pointer to the start of the retrieved data or NULL if something went wrong.
 373    If something does go wrong and REASON is not NULL then emit an error
 374    message using REASON as part of the context.  */
 375
 376 static void *
 377 get_data (void *         var,
 378           Filedata *     filedata,
 379           unsigned long  offset,
 380           bfd_size_type  size,
 381           bfd_size_type  nmemb,
 382           const char *   reason)
 383 {
 384   void * mvar;
 385   bfd_size_type amt = size * nmemb;
 386
 387   if (size == 0 || nmemb == 0)
 388     return NULL;
 389
 390   /* If the size_t type is smaller than the bfd_size_type, eg because
 391      you are building a 32-bit tool on a 64-bit host, then make sure
 392      that when the sizes are cast to (size_t) no information is lost.  */
 393   if ((size_t) size != size
 394       || (size_t) nmemb != nmemb
 395       || (size_t) amt != amt)
 396     {
 397       if (reason)
 398         error (_("Size truncation prevents reading %s"
 399                  " elements of size %s for %s\n"),
 400                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 401       return NULL;
 402     }
 403
 404   /* Check for size overflow.  */
 405   if (amt / size != nmemb || (size_t) amt + 1 == 0)
 406     {
 407       if (reason)
 408         error (_("Size overflow prevents reading %s"
 409                  " elements of size %s for %s\n"),
 410                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 411       return NULL;
 412     }
 413
 414   /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
 415      attempting to allocate memory when the read is bound to fail.  */
 416   if (archive_file_offset > filedata->file_size
 417       || offset > filedata->file_size - archive_file_offset
 418       || amt > filedata->file_size - archive_file_offset - offset)
 419     {
 420       if (reason)
 421         error (_("Reading %s bytes extends past end of file for %s\n"),
 422                bfd_vmatoa ("u", amt), reason);
 423       return NULL;
 424     }
 425
 426   if (fseek (filedata->handle, archive_file_offset + offset, SEEK_SET))
 427     {
 428       if (reason)
 429         error (_("Unable to seek to 0x%lx for %s\n"),
 430                archive_file_offset + offset, reason);
 431       return NULL;
 432     }
 433
 434   mvar = var;
 435   if (mvar == NULL)
 436     {
 437       /* + 1 so that we can '\0' terminate invalid string table sections.  */
 438       mvar = malloc ((size_t) amt + 1);
 439
 440       if (mvar == NULL)
 441         {
 442           if (reason)
 443             error (_("Out of memory allocating %s bytes for %s\n"),
 444                    bfd_vmatoa ("u", amt), reason);
 445           return NULL;
 446         }
 447
 448       ((char *) mvar)[amt] = '\0';
 449     }
 450
 451   if (fread (mvar, (size_t) size, (size_t) nmemb, filedata->handle) != nmemb)
 452     {
 453       if (reason)
 454         error (_("Unable to read in %s bytes of %s\n"),
 455                bfd_vmatoa ("u", amt), reason);
 456       if (mvar != var)
 457         free (mvar);
 458       return NULL;
 459     }
 460
 461   return mvar;
 462 }
 463
 464 /* Print a VMA value in the MODE specified.
 465    Returns the number of characters displayed.  */
 466
 467 static unsigned int
 468 print_vma (bfd_vma vma, print_mode mode)
 469 {
 470   unsigned int nc = 0;
 471
 472   switch (mode)
 473     {
 474     case FULL_HEX:
 475       nc = printf ("0x");
 476       /* Fall through.  */
 477     case LONG_HEX:
 478 #ifdef BFD64
 479       if (is_32bit_elf)
 480         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
 481 #endif
 482       printf_vma (vma);
 483       return nc + 16;
 484
 485     case DEC_5:
 486       if (vma <= 99999)
 487         return printf ("%5" BFD_VMA_FMT "d", vma);
 488       /* Fall through.  */
 489     case PREFIX_HEX:
 490       nc = printf ("0x");
 491       /* Fall through.  */
 492     case HEX:
 493       return nc + printf ("%" BFD_VMA_FMT "x", vma);
 494
 495     case DEC:
 496       return printf ("%" BFD_VMA_FMT "d", vma);
 497
 498     case UNSIGNED:
 499       return printf ("%" BFD_VMA_FMT "u", vma);
 500
 501     default:
 502       /* FIXME: Report unrecognised mode ?  */
 503       return 0;
 504     }
 505 }
 506
 507 /* Display a symbol on stdout.  Handles the display of control characters and
 508    multibye characters (assuming the host environment supports them).
 509
 510    Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
 511
 512    If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
 513    padding as necessary.
 514
 515    Returns the number of emitted characters.  */
 516
 517 static unsigned int
 518 print_symbol (signed int width, const char *symbol)
 519 {
 520   bfd_boolean extra_padding = FALSE;
 521   signed int num_printed = 0;
 522 #ifdef HAVE_MBSTATE_T
 523   mbstate_t state;
 524 #endif
 525   unsigned int width_remaining;
 526
 527   if (width < 0)
 528     {
 529       /* Keep the width positive.  This helps the code below.  */
 530       width = - width;
 531       extra_padding = TRUE;
 532     }
 533   else if (width == 0)
 534     return 0;
 535
 536   if (do_wide)
 537     /* Set the remaining width to a very large value.
 538        This simplifies the code below.  */
 539     width_remaining = INT_MAX;
 540   else
 541     width_remaining = width;
 542
 543 #ifdef HAVE_MBSTATE_T
 544   /* Initialise the multibyte conversion state.  */
 545   memset (& state, 0, sizeof (state));
 546 #endif
 547
 548   while (width_remaining)
 549     {
 550       size_t  n;
 551       const char c = *symbol++;
 552
 553       if (c == 0)
 554         break;
 555
 556       /* Do not print control characters directly as they can affect terminal
 557          settings.  Such characters usually appear in the names generated
 558          by the assembler for local labels.  */
 559       if (ISCNTRL (c))
 560         {
 561           if (width_remaining < 2)
 562             break;
 563
 564           printf ("^%c", c + 0x40);
 565           width_remaining -= 2;
 566           num_printed += 2;
 567         }
 568       else if (ISPRINT (c))
 569         {
 570           putchar (c);
 571           width_remaining --;
 572           num_printed ++;
 573         }
 574       else
 575         {
 576 #ifdef HAVE_MBSTATE_T
 577           wchar_t w;
 578 #endif
 579           /* Let printf do the hard work of displaying multibyte characters.  */
 580           printf ("%.1s", symbol - 1);
 581           width_remaining --;
 582           num_printed ++;
 583
 584 #ifdef HAVE_MBSTATE_T
 585           /* Try to find out how many bytes made up the character that was
 586              just printed.  Advance the symbol pointer past the bytes that
 587              were displayed.  */
 588           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 589 #else
 590           n = 1;
 591 #endif
 592           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 593             symbol += (n - 1);
 594         }
 595     }
 596
 597   if (extra_padding && num_printed < width)
 598     {
 599       /* Fill in the remaining spaces.  */
 600       printf ("%-*s", width - num_printed, " ");
 601       num_printed = width;
 602     }
 603
 604   return num_printed;
 605 }
 606
 607 /* Returns a pointer to a static buffer containing a printable version of
 608    the given section's name.  Like print_symbol, except that it does not try
 609    to print multibyte characters, it just interprets them as hex values.  */
 610
 611 static const char *
 612 printable_section_name (Filedata * filedata, const Elf_Internal_Shdr * sec)
 613 {
 614 #define MAX_PRINT_SEC_NAME_LEN 128
 615   static char  sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
 616   const char * name = SECTION_NAME (sec);
 617   char *       buf = sec_name_buf;
 618   char         c;
 619   unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
 620
 621   while ((c = * name ++) != 0)
 622     {
 623       if (ISCNTRL (c))
 624         {
 625           if (remaining < 2)
 626             break;
 627
 628           * buf ++ = '^';
 629           * buf ++ = c + 0x40;
 630           remaining -= 2;
 631         }
 632       else if (ISPRINT (c))
 633         {
 634           * buf ++ = c;
 635           remaining -= 1;
 636         }
 637       else
 638         {
 639           static char hex[17] = "0123456789ABCDEF";
 640
 641           if (remaining < 4)
 642             break;
 643           * buf ++ = '<';
 644           * buf ++ = hex[(c & 0xf0) >> 4];
 645           * buf ++ = hex[c & 0x0f];
 646           * buf ++ = '>';
 647           remaining -= 4;
 648         }
 649
 650       if (remaining == 0)
 651         break;
 652     }
 653
 654   * buf = 0;
 655   return sec_name_buf;
 656 }
 657
 658 static const char *
 659 printable_section_name_from_index (Filedata * filedata, unsigned long ndx)
 660 {
 661   if (ndx >= filedata->file_header.e_shnum)
 662     return _("<corrupt>");
 663
 664   return printable_section_name (filedata, filedata->section_headers + ndx);
 665 }
 666
 667 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 668
 669 static Elf_Internal_Shdr *
 670 find_section (Filedata * filedata, const char * name)
 671 {
 672   unsigned int i;
 673
 674   if (filedata->section_headers == NULL)
 675     return NULL;
 676
 677   for (i = 0; i < filedata->file_header.e_shnum; i++)
 678     if (streq (SECTION_NAME (filedata->section_headers + i), name))
 679       return filedata->section_headers + i;
 680
 681   return NULL;
 682 }
 683
 684 /* Return a pointer to a section containing ADDR, or NULL if no such
 685    section exists.  */
 686
 687 static Elf_Internal_Shdr *
 688 find_section_by_address (Filedata * filedata, bfd_vma addr)
 689 {
 690   unsigned int i;
 691
 692   if (filedata->section_headers == NULL)
 693     return NULL;
 694
 695   for (i = 0; i < filedata->file_header.e_shnum; i++)
 696     {
 697       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 698
 699       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 700         return sec;
 701     }
 702
 703   return NULL;
 704 }
 705
 706 static Elf_Internal_Shdr *
 707 find_section_by_type (Filedata * filedata, unsigned int type)
 708 {
 709   unsigned int i;
 710
 711   if (filedata->section_headers == NULL)
 712     return NULL;
 713
 714   for (i = 0; i < filedata->file_header.e_shnum; i++)
 715     {
 716       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 717
 718       if (sec->sh_type == type)
 719         return sec;
 720     }
 721
 722   return NULL;
 723 }
 724
 725 /* Return a pointer to section NAME, or NULL if no such section exists,
 726    restricted to the list of sections given in SET.  */
 727
 728 static Elf_Internal_Shdr *
 729 find_section_in_set (Filedata * filedata, const char * name, unsigned int * set)
 730 {
 731   unsigned int i;
 732
 733   if (filedata->section_headers == NULL)
 734     return NULL;
 735
 736   if (set != NULL)
 737     {
 738       while ((i = *set++) > 0)
 739         {
 740           /* See PR 21156 for a reproducer.  */
 741           if (i >= filedata->file_header.e_shnum)
 742             continue; /* FIXME: Should we issue an error message ?  */
 743
 744           if (streq (SECTION_NAME (filedata->section_headers + i), name))
 745             return filedata->section_headers + i;
 746         }
 747     }
 748
 749   return find_section (filedata, name);
 750 }
 751
 752 /* Read an unsigned LEB128 encoded value from DATA.
 753    Set *LENGTH_RETURN to the number of bytes read.  */
 754
 755 static inline unsigned long
 756 read_uleb128 (unsigned char * data,
 757               unsigned int * length_return,
 758               const unsigned char * const end)
 759 {
 760   return read_leb128 (data, length_return, FALSE, end);
 761 }
 762
 763 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
 764    This OS has so many departures from the ELF standard that we test it at
 765    many places.  */
 766
 767 static inline bfd_boolean
 768 is_ia64_vms (Filedata * filedata)
 769 {
 770   return filedata->file_header.e_machine == EM_IA_64
 771     && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 772 }
 773
 774 /* Guess the relocation size commonly used by the specific machines.  */
 775
 776 static bfd_boolean
 777 guess_is_rela (unsigned int e_machine)
 778 {
 779   switch (e_machine)
 780     {
 781       /* Targets that use REL relocations.  */
 782     case EM_386:
 783     case EM_IAMCU:
 784     case EM_960:
 785     case EM_ARM:
 786     case EM_D10V:
 787     case EM_CYGNUS_D10V:
 788     case EM_DLX:
 789     case EM_MIPS:
 790     case EM_MIPS_RS3_LE:
 791     case EM_CYGNUS_M32R:
 792     case EM_SCORE:
 793     case EM_XGATE:
 794     case EM_NFP:
 795     case EM_BPF:
 796       return FALSE;
 797
 798       /* Targets that use RELA relocations.  */
 799     case EM_68K:
 800     case EM_860:
 801     case EM_AARCH64:
 802     case EM_ADAPTEVA_EPIPHANY:
 803     case EM_ALPHA:
 804     case EM_ALTERA_NIOS2:
 805     case EM_ARC:
 806     case EM_ARC_COMPACT:
 807     case EM_ARC_COMPACT2:
 808     case EM_AVR:
 809     case EM_AVR_OLD:
 810     case EM_BLACKFIN:
 811     case EM_CR16:
 812     case EM_CRIS:
 813     case EM_CRX:
 814     case EM_CSKY:
 815     case EM_D30V:
 816     case EM_CYGNUS_D30V:
 817     case EM_FR30:
 818     case EM_FT32:
 819     case EM_CYGNUS_FR30:
 820     case EM_CYGNUS_FRV:
 821     case EM_H8S:
 822     case EM_H8_300:
 823     case EM_H8_300H:
 824     case EM_IA_64:
 825     case EM_IP2K:
 826     case EM_IP2K_OLD:
 827     case EM_IQ2000:
 828     case EM_LATTICEMICO32:
 829     case EM_M32C_OLD:
 830     case EM_M32C:
 831     case EM_M32R:
 832     case EM_MCORE:
 833     case EM_CYGNUS_MEP:
 834     case EM_METAG:
 835     case EM_MMIX:
 836     case EM_MN10200:
 837     case EM_CYGNUS_MN10200:
 838     case EM_MN10300:
 839     case EM_CYGNUS_MN10300:
 840     case EM_MOXIE:
 841     case EM_MSP430:
 842     case EM_MSP430_OLD:
 843     case EM_MT:
 844     case EM_NDS32:
 845     case EM_NIOS32:
 846     case EM_OR1K:
 847     case EM_PPC64:
 848     case EM_PPC:
 849     case EM_TI_PRU:
 850     case EM_RISCV:
 851     case EM_RL78:
 852     case EM_RX:
 853     case EM_S390:
 854     case EM_S390_OLD:
 855     case EM_SH:
 856     case EM_SPARC:
 857     case EM_SPARC32PLUS:
 858     case EM_SPARCV9:
 859     case EM_SPU:
 860     case EM_TI_C6000:
 861     case EM_TILEGX:
 862     case EM_TILEPRO:
 863     case EM_V800:
 864     case EM_V850:
 865     case EM_CYGNUS_V850:
 866     case EM_VAX:
 867     case EM_VISIUM:
 868     case EM_X86_64:
 869     case EM_L1OM:
 870     case EM_K1OM:
 871     case EM_XSTORMY16:
 872     case EM_XTENSA:
 873     case EM_XTENSA_OLD:
 874     case EM_MICROBLAZE:
 875     case EM_MICROBLAZE_OLD:
 876     case EM_WEBASSEMBLY:
 877       return TRUE;
 878
 879     case EM_68HC05:
 880     case EM_68HC08:
 881     case EM_68HC11:
 882     case EM_68HC16:
 883     case EM_FX66:
 884     case EM_ME16:
 885     case EM_MMA:
 886     case EM_NCPU:
 887     case EM_NDR1:
 888     case EM_PCP:
 889     case EM_ST100:
 890     case EM_ST19:
 891     case EM_ST7:
 892     case EM_ST9PLUS:
 893     case EM_STARCORE:
 894     case EM_SVX:
 895     case EM_TINYJ:
 896     default:
 897       warn (_("Don't know about relocations on this machine architecture\n"));
 898       return FALSE;
 899     }
 900 }
 901
 902 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 903    Returns TRUE upon success, FALSE otherwise.  If successful then a
 904    pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
 905    and the number of relocs loaded is placed in *NRELASP.  It is the caller's
 906    responsibility to free the allocated buffer.  */
 907
 908 static bfd_boolean
 909 slurp_rela_relocs (Filedata *            filedata,
 910                    unsigned long         rel_offset,
 911                    unsigned long         rel_size,
 912                    Elf_Internal_Rela **  relasp,
 913                    unsigned long *       nrelasp)
 914 {
 915   Elf_Internal_Rela * relas;
 916   size_t nrelas;
 917   unsigned int i;
 918
 919   if (is_32bit_elf)
 920     {
 921       Elf32_External_Rela * erelas;
 922
 923       erelas = (Elf32_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 924                                                  rel_size, _("32-bit relocation data"));
 925       if (!erelas)
 926         return FALSE;
 927
 928       nrelas = rel_size / sizeof (Elf32_External_Rela);
 929
 930       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 931                                              sizeof (Elf_Internal_Rela));
 932
 933       if (relas == NULL)
 934         {
 935           free (erelas);
 936           error (_("out of memory parsing relocs\n"));
 937           return FALSE;
 938         }
 939
 940       for (i = 0; i < nrelas; i++)
 941         {
 942           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 943           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 944           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 945         }
 946
 947       free (erelas);
 948     }
 949   else
 950     {
 951       Elf64_External_Rela * erelas;
 952
 953       erelas = (Elf64_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 954                                                  rel_size, _("64-bit relocation data"));
 955       if (!erelas)
 956         return FALSE;
 957
 958       nrelas = rel_size / sizeof (Elf64_External_Rela);
 959
 960       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 961                                              sizeof (Elf_Internal_Rela));
 962
 963       if (relas == NULL)
 964         {
 965           free (erelas);
 966           error (_("out of memory parsing relocs\n"));
 967           return FALSE;
 968         }
 969
 970       for (i = 0; i < nrelas; i++)
 971         {
 972           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 973           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 974           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 975
 976           /* The #ifdef BFD64 below is to prevent a compile time
 977              warning.  We know that if we do not have a 64 bit data
 978              type that we will never execute this code anyway.  */
 979 #ifdef BFD64
 980           if (filedata->file_header.e_machine == EM_MIPS
 981               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
 982             {
 983               /* In little-endian objects, r_info isn't really a
 984                  64-bit little-endian value: it has a 32-bit
 985                  little-endian symbol index followed by four
 986                  individual byte fields.  Reorder INFO
 987                  accordingly.  */
 988               bfd_vma inf = relas[i].r_info;
 989               inf = (((inf & 0xffffffff) << 32)
 990                       | ((inf >> 56) & 0xff)
 991                       | ((inf >> 40) & 0xff00)
 992                       | ((inf >> 24) & 0xff0000)
 993                       | ((inf >> 8) & 0xff000000));
 994               relas[i].r_info = inf;
 995             }
 996 #endif /* BFD64 */
 997         }
 998
 999       free (erelas);
1000     }
1001
1002   *relasp = relas;
1003   *nrelasp = nrelas;
1004   return TRUE;
1005 }
1006
1007 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1008    Returns TRUE upon success, FALSE otherwise.  If successful then a
1009    pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1010    and the number of relocs loaded is placed in *NRELSP.  It is the caller's
1011    responsibility to free the allocated buffer.  */
1012
1013 static bfd_boolean
1014 slurp_rel_relocs (Filedata *            filedata,
1015                   unsigned long         rel_offset,
1016                   unsigned long         rel_size,
1017                   Elf_Internal_Rela **  relsp,
1018                   unsigned long *       nrelsp)
1019 {
1020   Elf_Internal_Rela * rels;
1021   size_t nrels;
1022   unsigned int i;
1023
1024   if (is_32bit_elf)
1025     {
1026       Elf32_External_Rel * erels;
1027
1028       erels = (Elf32_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1029                                                rel_size, _("32-bit relocation data"));
1030       if (!erels)
1031         return FALSE;
1032
1033       nrels = rel_size / sizeof (Elf32_External_Rel);
1034
1035       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1036
1037       if (rels == NULL)
1038         {
1039           free (erels);
1040           error (_("out of memory parsing relocs\n"));
1041           return FALSE;
1042         }
1043
1044       for (i = 0; i < nrels; i++)
1045         {
1046           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1047           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1048           rels[i].r_addend = 0;
1049         }
1050
1051       free (erels);
1052     }
1053   else
1054     {
1055       Elf64_External_Rel * erels;
1056
1057       erels = (Elf64_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1058                                                rel_size, _("64-bit relocation data"));
1059       if (!erels)
1060         return FALSE;
1061
1062       nrels = rel_size / sizeof (Elf64_External_Rel);
1063
1064       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1065
1066       if (rels == NULL)
1067         {
1068           free (erels);
1069           error (_("out of memory parsing relocs\n"));
1070           return FALSE;
1071         }
1072
1073       for (i = 0; i < nrels; i++)
1074         {
1075           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1076           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1077           rels[i].r_addend = 0;
1078
1079           /* The #ifdef BFD64 below is to prevent a compile time
1080              warning.  We know that if we do not have a 64 bit data
1081              type that we will never execute this code anyway.  */
1082 #ifdef BFD64
1083           if (filedata->file_header.e_machine == EM_MIPS
1084               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
1085             {
1086               /* In little-endian objects, r_info isn't really a
1087                  64-bit little-endian value: it has a 32-bit
1088                  little-endian symbol index followed by four
1089                  individual byte fields.  Reorder INFO
1090                  accordingly.  */
1091               bfd_vma inf = rels[i].r_info;
1092               inf = (((inf & 0xffffffff) << 32)
1093                      | ((inf >> 56) & 0xff)
1094                      | ((inf >> 40) & 0xff00)
1095                      | ((inf >> 24) & 0xff0000)
1096                      | ((inf >> 8) & 0xff000000));
1097               rels[i].r_info = inf;
1098             }
1099 #endif /* BFD64 */
1100         }
1101
1102       free (erels);
1103     }
1104
1105   *relsp = rels;
1106   *nrelsp = nrels;
1107   return TRUE;
1108 }
1109
1110 /* Returns the reloc type extracted from the reloc info field.  */
1111
1112 static unsigned int
1113 get_reloc_type (Filedata * filedata, bfd_vma reloc_info)
1114 {
1115   if (is_32bit_elf)
1116     return ELF32_R_TYPE (reloc_info);
1117
1118   switch (filedata->file_header.e_machine)
1119     {
1120     case EM_MIPS:
1121       /* Note: We assume that reloc_info has already been adjusted for us.  */
1122       return ELF64_MIPS_R_TYPE (reloc_info);
1123
1124     case EM_SPARCV9:
1125       return ELF64_R_TYPE_ID (reloc_info);
1126
1127     default:
1128       return ELF64_R_TYPE (reloc_info);
1129     }
1130 }
1131
1132 /* Return the symbol index extracted from the reloc info field.  */
1133
1134 static bfd_vma
1135 get_reloc_symindex (bfd_vma reloc_info)
1136 {
1137   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1138 }
1139
1140 static inline bfd_boolean
1141 uses_msp430x_relocs (Filedata * filedata)
1142 {
1143   return
1144     filedata->file_header.e_machine == EM_MSP430 /* Paranoia.  */
1145     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
1146     && (((filedata->file_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1147         /* TI compiler uses ELFOSABI_NONE.  */
1148         || (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1149 }
1150
1151 /* Display the contents of the relocation data found at the specified
1152    offset.  */
1153
1154 static bfd_boolean
1155 dump_relocations (Filedata *          filedata,
1156                   unsigned long       rel_offset,
1157                   unsigned long       rel_size,
1158                   Elf_Internal_Sym *  symtab,
1159                   unsigned long       nsyms,
1160                   char *              strtab,
1161                   unsigned long       strtablen,
1162                   int                 is_rela,
1163                   bfd_boolean         is_dynsym)
1164 {
1165   unsigned long i;
1166   Elf_Internal_Rela * rels;
1167   bfd_boolean res = TRUE;
1168
1169   if (is_rela == UNKNOWN)
1170     is_rela = guess_is_rela (filedata->file_header.e_machine);
1171
1172   if (is_rela)
1173     {
1174       if (!slurp_rela_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1175         return FALSE;
1176     }
1177   else
1178     {
1179       if (!slurp_rel_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1180         return FALSE;
1181     }
1182
1183   if (is_32bit_elf)
1184     {
1185       if (is_rela)
1186         {
1187           if (do_wide)
1188             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
1189           else
1190             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
1191         }
1192       else
1193         {
1194           if (do_wide)
1195             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
1196           else
1197             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
1198         }
1199     }
1200   else
1201     {
1202       if (is_rela)
1203         {
1204           if (do_wide)
1205             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
1206           else
1207             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
1208         }
1209       else
1210         {
1211           if (do_wide)
1212             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
1213           else
1214             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
1215         }
1216     }
1217
1218   for (i = 0; i < rel_size; i++)
1219     {
1220       const char * rtype;
1221       bfd_vma offset;
1222       bfd_vma inf;
1223       bfd_vma symtab_index;
1224       bfd_vma type;
1225
1226       offset = rels[i].r_offset;
1227       inf    = rels[i].r_info;
1228
1229       type = get_reloc_type (filedata, inf);
1230       symtab_index = get_reloc_symindex  (inf);
1231
1232       if (is_32bit_elf)
1233         {
1234           printf ("%8.8lx  %8.8lx ",
1235                   (unsigned long) offset & 0xffffffff,
1236                   (unsigned long) inf & 0xffffffff);
1237         }
1238       else
1239         {
1240 #if BFD_HOST_64BIT_LONG
1241           printf (do_wide
1242                   ? "%16.16lx  %16.16lx "
1243                   : "%12.12lx  %12.12lx ",
1244                   offset, inf);
1245 #elif BFD_HOST_64BIT_LONG_LONG
1246 #ifndef __MSVCRT__
1247           printf (do_wide
1248                   ? "%16.16llx  %16.16llx "
1249                   : "%12.12llx  %12.12llx ",
1250                   offset, inf);
1251 #else
1252           printf (do_wide
1253                   ? "%16.16I64x  %16.16I64x "
1254                   : "%12.12I64x  %12.12I64x ",
1255                   offset, inf);
1256 #endif
1257 #else
1258           printf (do_wide
1259                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1260                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1261                   _bfd_int64_high (offset),
1262                   _bfd_int64_low (offset),
1263                   _bfd_int64_high (inf),
1264                   _bfd_int64_low (inf));
1265 #endif
1266         }
1267
1268       switch (filedata->file_header.e_machine)
1269         {
1270         default:
1271           rtype = NULL;
1272           break;
1273
1274         case EM_AARCH64:
1275           rtype = elf_aarch64_reloc_type (type);
1276           break;
1277
1278         case EM_M32R:
1279         case EM_CYGNUS_M32R:
1280           rtype = elf_m32r_reloc_type (type);
1281           break;
1282
1283         case EM_386:
1284         case EM_IAMCU:
1285           rtype = elf_i386_reloc_type (type);
1286           break;
1287
1288         case EM_68HC11:
1289         case EM_68HC12:
1290           rtype = elf_m68hc11_reloc_type (type);
1291           break;
1292
1293         case EM_S12Z:
1294           rtype = elf_s12z_reloc_type (type);
1295           break;
1296
1297         case EM_68K:
1298           rtype = elf_m68k_reloc_type (type);
1299           break;
1300
1301         case EM_960:
1302           rtype = elf_i960_reloc_type (type);
1303           break;
1304
1305         case EM_AVR:
1306         case EM_AVR_OLD:
1307           rtype = elf_avr_reloc_type (type);
1308           break;
1309
1310         case EM_OLD_SPARCV9:
1311         case EM_SPARC32PLUS:
1312         case EM_SPARCV9:
1313         case EM_SPARC:
1314           rtype = elf_sparc_reloc_type (type);
1315           break;
1316
1317         case EM_SPU:
1318           rtype = elf_spu_reloc_type (type);
1319           break;
1320
1321         case EM_V800:
1322           rtype = v800_reloc_type (type);
1323           break;
1324         case EM_V850:
1325         case EM_CYGNUS_V850:
1326           rtype = v850_reloc_type (type);
1327           break;
1328
1329         case EM_D10V:
1330         case EM_CYGNUS_D10V:
1331           rtype = elf_d10v_reloc_type (type);
1332           break;
1333
1334         case EM_D30V:
1335         case EM_CYGNUS_D30V:
1336           rtype = elf_d30v_reloc_type (type);
1337           break;
1338
1339         case EM_DLX:
1340           rtype = elf_dlx_reloc_type (type);
1341           break;
1342
1343         case EM_SH:
1344           rtype = elf_sh_reloc_type (type);
1345           break;
1346
1347         case EM_MN10300:
1348         case EM_CYGNUS_MN10300:
1349           rtype = elf_mn10300_reloc_type (type);
1350           break;
1351
1352         case EM_MN10200:
1353         case EM_CYGNUS_MN10200:
1354           rtype = elf_mn10200_reloc_type (type);
1355           break;
1356
1357         case EM_FR30:
1358         case EM_CYGNUS_FR30:
1359           rtype = elf_fr30_reloc_type (type);
1360           break;
1361
1362         case EM_CYGNUS_FRV:
1363           rtype = elf_frv_reloc_type (type);
1364           break;
1365
1366         case EM_CSKY:
1367           rtype = elf_csky_reloc_type (type);
1368           break;
1369
1370         case EM_FT32:
1371           rtype = elf_ft32_reloc_type (type);
1372           break;
1373
1374         case EM_MCORE:
1375           rtype = elf_mcore_reloc_type (type);
1376           break;
1377
1378         case EM_MMIX:
1379           rtype = elf_mmix_reloc_type (type);
1380           break;
1381
1382         case EM_MOXIE:
1383           rtype = elf_moxie_reloc_type (type);
1384           break;
1385
1386         case EM_MSP430:
1387           if (uses_msp430x_relocs (filedata))
1388             {
1389               rtype = elf_msp430x_reloc_type (type);
1390               break;
1391             }
1392           /* Fall through.  */
1393         case EM_MSP430_OLD:
1394           rtype = elf_msp430_reloc_type (type);
1395           break;
1396
1397         case EM_NDS32:
1398           rtype = elf_nds32_reloc_type (type);
1399           break;
1400
1401         case EM_PPC:
1402           rtype = elf_ppc_reloc_type (type);
1403           break;
1404
1405         case EM_PPC64:
1406           rtype = elf_ppc64_reloc_type (type);
1407           break;
1408
1409         case EM_MIPS:
1410         case EM_MIPS_RS3_LE:
1411           rtype = elf_mips_reloc_type (type);
1412           break;
1413
1414         case EM_RISCV:
1415           rtype = elf_riscv_reloc_type (type);
1416           break;
1417
1418         case EM_ALPHA:
1419           rtype = elf_alpha_reloc_type (type);
1420           break;
1421
1422         case EM_ARM:
1423           rtype = elf_arm_reloc_type (type);
1424           break;
1425
1426         case EM_ARC:
1427         case EM_ARC_COMPACT:
1428         case EM_ARC_COMPACT2:
1429           rtype = elf_arc_reloc_type (type);
1430           break;
1431
1432         case EM_PARISC:
1433           rtype = elf_hppa_reloc_type (type);
1434           break;
1435
1436         case EM_H8_300:
1437         case EM_H8_300H:
1438         case EM_H8S:
1439           rtype = elf_h8_reloc_type (type);
1440           break;
1441
1442         case EM_OR1K:
1443           rtype = elf_or1k_reloc_type (type);
1444           break;
1445
1446         case EM_PJ:
1447         case EM_PJ_OLD:
1448           rtype = elf_pj_reloc_type (type);
1449           break;
1450         case EM_IA_64:
1451           rtype = elf_ia64_reloc_type (type);
1452           break;
1453
1454         case EM_CRIS:
1455           rtype = elf_cris_reloc_type (type);
1456           break;
1457
1458         case EM_860:
1459           rtype = elf_i860_reloc_type (type);
1460           break;
1461
1462         case EM_X86_64:
1463         case EM_L1OM:
1464         case EM_K1OM:
1465           rtype = elf_x86_64_reloc_type (type);
1466           break;
1467
1468         case EM_S370:
1469           rtype = i370_reloc_type (type);
1470           break;
1471
1472         case EM_S390_OLD:
1473         case EM_S390:
1474           rtype = elf_s390_reloc_type (type);
1475           break;
1476
1477         case EM_SCORE:
1478           rtype = elf_score_reloc_type (type);
1479           break;
1480
1481         case EM_XSTORMY16:
1482           rtype = elf_xstormy16_reloc_type (type);
1483           break;
1484
1485         case EM_CRX:
1486           rtype = elf_crx_reloc_type (type);
1487           break;
1488
1489         case EM_VAX:
1490           rtype = elf_vax_reloc_type (type);
1491           break;
1492
1493         case EM_VISIUM:
1494           rtype = elf_visium_reloc_type (type);
1495           break;
1496
1497         case EM_BPF:
1498           rtype = elf_bpf_reloc_type (type);
1499           break;
1500
1501         case EM_ADAPTEVA_EPIPHANY:
1502           rtype = elf_epiphany_reloc_type (type);
1503           break;
1504
1505         case EM_IP2K:
1506         case EM_IP2K_OLD:
1507           rtype = elf_ip2k_reloc_type (type);
1508           break;
1509
1510         case EM_IQ2000:
1511           rtype = elf_iq2000_reloc_type (type);
1512           break;
1513
1514         case EM_XTENSA_OLD:
1515         case EM_XTENSA:
1516           rtype = elf_xtensa_reloc_type (type);
1517           break;
1518
1519         case EM_LATTICEMICO32:
1520           rtype = elf_lm32_reloc_type (type);
1521           break;
1522
1523         case EM_M32C_OLD:
1524         case EM_M32C:
1525           rtype = elf_m32c_reloc_type (type);
1526           break;
1527
1528         case EM_MT:
1529           rtype = elf_mt_reloc_type (type);
1530           break;
1531
1532         case EM_BLACKFIN:
1533           rtype = elf_bfin_reloc_type (type);
1534           break;
1535
1536         case EM_CYGNUS_MEP:
1537           rtype = elf_mep_reloc_type (type);
1538           break;
1539
1540         case EM_CR16:
1541           rtype = elf_cr16_reloc_type (type);
1542           break;
1543
1544         case EM_MICROBLAZE:
1545         case EM_MICROBLAZE_OLD:
1546           rtype = elf_microblaze_reloc_type (type);
1547           break;
1548
1549         case EM_RL78:
1550           rtype = elf_rl78_reloc_type (type);
1551           break;
1552
1553         case EM_RX:
1554           rtype = elf_rx_reloc_type (type);
1555           break;
1556
1557         case EM_METAG:
1558           rtype = elf_metag_reloc_type (type);
1559           break;
1560
1561         case EM_XC16X:
1562         case EM_C166:
1563           rtype = elf_xc16x_reloc_type (type);
1564           break;
1565
1566         case EM_TI_C6000:
1567           rtype = elf_tic6x_reloc_type (type);
1568           break;
1569
1570         case EM_TILEGX:
1571           rtype = elf_tilegx_reloc_type (type);
1572           break;
1573
1574         case EM_TILEPRO:
1575           rtype = elf_tilepro_reloc_type (type);
1576           break;
1577
1578         case EM_WEBASSEMBLY:
1579           rtype = elf_wasm32_reloc_type (type);
1580           break;
1581
1582         case EM_XGATE:
1583           rtype = elf_xgate_reloc_type (type);
1584           break;
1585
1586         case EM_ALTERA_NIOS2:
1587           rtype = elf_nios2_reloc_type (type);
1588           break;
1589
1590         case EM_TI_PRU:
1591           rtype = elf_pru_reloc_type (type);
1592           break;
1593
1594         case EM_NFP:
1595           if (EF_NFP_MACH (filedata->file_header.e_flags) == E_NFP_MACH_3200)
1596             rtype = elf_nfp3200_reloc_type (type);
1597           else
1598             rtype = elf_nfp_reloc_type (type);
1599           break;
1600         }
1601
1602       if (rtype == NULL)
1603         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1604       else
1605         printf (do_wide ? "%-22s" : "%-17.17s", rtype);
1606
1607       if (filedata->file_header.e_machine == EM_ALPHA
1608           && rtype != NULL
1609           && streq (rtype, "R_ALPHA_LITUSE")
1610           && is_rela)
1611         {
1612           switch (rels[i].r_addend)
1613             {
1614             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1615             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1616             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1617             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1618             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1619             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1620             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1621             default: rtype = NULL;
1622             }
1623
1624           if (rtype)
1625             printf (" (%s)", rtype);
1626           else
1627             {
1628               putchar (' ');
1629               printf (_("<unknown addend: %lx>"),
1630                       (unsigned long) rels[i].r_addend);
1631               res = FALSE;
1632             }
1633         }
1634       else if (symtab_index)
1635         {
1636           if (symtab == NULL || symtab_index >= nsyms)
1637             {
1638               error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1639               res = FALSE;
1640             }
1641           else
1642             {
1643               Elf_Internal_Sym * psym;
1644               const char * version_string;
1645               enum versioned_symbol_info sym_info;
1646               unsigned short vna_other;
1647
1648               psym = symtab + symtab_index;
1649
1650               version_string
1651                 = get_symbol_version_string (filedata, is_dynsym,
1652                                              strtab, strtablen,
1653                                              symtab_index,
1654                                              psym,
1655                                              &sym_info,
1656                                              &vna_other);
1657
1658               printf (" ");
1659
1660               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1661                 {
1662                   const char * name;
1663                   unsigned int len;
1664                   unsigned int width = is_32bit_elf ? 8 : 14;
1665
1666                   /* Relocations against GNU_IFUNC symbols do not use the value
1667                      of the symbol as the address to relocate against.  Instead
1668                      they invoke the function named by the symbol and use its
1669                      result as the address for relocation.
1670
1671                      To indicate this to the user, do not display the value of
1672                      the symbol in the "Symbols's Value" field.  Instead show
1673                      its name followed by () as a hint that the symbol is
1674                      invoked.  */
1675
1676                   if (strtab == NULL
1677                       || psym->st_name == 0
1678                       || psym->st_name >= strtablen)
1679                     name = "??";
1680                   else
1681                     name = strtab + psym->st_name;
1682
1683                   len = print_symbol (width, name);
1684                   if (version_string)
1685                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1686                             version_string);
1687                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1688                 }
1689               else
1690                 {
1691                   print_vma (psym->st_value, LONG_HEX);
1692
1693                   printf (is_32bit_elf ? "   " : " ");
1694                 }
1695
1696               if (psym->st_name == 0)
1697                 {
1698                   const char * sec_name = "<null>";
1699                   char name_buf[40];
1700
1701                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1702                     {
1703                       if (psym->st_shndx < filedata->file_header.e_shnum)
1704                         sec_name = SECTION_NAME (filedata->section_headers + psym->st_shndx);
1705                       else if (psym->st_shndx == SHN_ABS)
1706                         sec_name = "ABS";
1707                       else if (psym->st_shndx == SHN_COMMON)
1708                         sec_name = "COMMON";
1709                       else if ((filedata->file_header.e_machine == EM_MIPS
1710                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1711                                || (filedata->file_header.e_machine == EM_TI_C6000
1712                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1713                         sec_name = "SCOMMON";
1714                       else if (filedata->file_header.e_machine == EM_MIPS
1715                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1716                         sec_name = "SUNDEF";
1717                       else if ((filedata->file_header.e_machine == EM_X86_64
1718                                 || filedata->file_header.e_machine == EM_L1OM
1719                                 || filedata->file_header.e_machine == EM_K1OM)
1720                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1721                         sec_name = "LARGE_COMMON";
1722                       else if (filedata->file_header.e_machine == EM_IA_64
1723                                && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1724                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1725                         sec_name = "ANSI_COM";
1726                       else if (is_ia64_vms (filedata)
1727                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1728                         sec_name = "VMS_SYMVEC";
1729                       else
1730                         {
1731                           sprintf (name_buf, "<section 0x%x>",
1732                                    (unsigned int) psym->st_shndx);
1733                           sec_name = name_buf;
1734                         }
1735                     }
1736                   print_symbol (22, sec_name);
1737                 }
1738               else if (strtab == NULL)
1739                 printf (_("<string table index: %3ld>"), psym->st_name);
1740               else if (psym->st_name >= strtablen)
1741                 {
1742                   error (_("<corrupt string table index: %3ld>"), psym->st_name);
1743                   res = FALSE;
1744                 }
1745               else
1746                 {
1747                   print_symbol (22, strtab + psym->st_name);
1748                   if (version_string)
1749                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1750                             version_string);
1751                 }
1752
1753               if (is_rela)
1754                 {
1755                   bfd_vma off = rels[i].r_addend;
1756
1757                   if ((bfd_signed_vma) off < 0)
1758                     printf (" - %" BFD_VMA_FMT "x", - off);
1759                   else
1760                     printf (" + %" BFD_VMA_FMT "x", off);
1761                 }
1762             }
1763         }
1764       else if (is_rela)
1765         {
1766           bfd_vma off = rels[i].r_addend;
1767
1768           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1769           if ((bfd_signed_vma) off < 0)
1770             printf ("-%" BFD_VMA_FMT "x", - off);
1771           else
1772             printf ("%" BFD_VMA_FMT "x", off);
1773         }
1774
1775       if (filedata->file_header.e_machine == EM_SPARCV9
1776           && rtype != NULL
1777           && streq (rtype, "R_SPARC_OLO10"))
1778         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1779
1780       putchar ('\n');
1781
1782 #ifdef BFD64
1783       if (! is_32bit_elf && filedata->file_header.e_machine == EM_MIPS)
1784         {
1785           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1786           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1787           const char * rtype2 = elf_mips_reloc_type (type2);
1788           const char * rtype3 = elf_mips_reloc_type (type3);
1789
1790           printf ("                    Type2: ");
1791
1792           if (rtype2 == NULL)
1793             printf (_("unrecognized: %-7lx"),
1794                     (unsigned long) type2 & 0xffffffff);
1795           else
1796             printf ("%-17.17s", rtype2);
1797
1798           printf ("\n                    Type3: ");
1799
1800           if (rtype3 == NULL)
1801             printf (_("unrecognized: %-7lx"),
1802                     (unsigned long) type3 & 0xffffffff);
1803           else
1804             printf ("%-17.17s", rtype3);
1805
1806           putchar ('\n');
1807         }
1808 #endif /* BFD64 */
1809     }
1810
1811   free (rels);
1812
1813   return res;
1814 }
1815
1816 static const char *
1817 get_aarch64_dynamic_type (unsigned long type)
1818 {
1819   switch (type)
1820     {
1821     case DT_AARCH64_BTI_PLT:  return "AARCH64_BTI_PLT";
1822     case DT_AARCH64_PAC_PLT:  return "AARCH64_PAC_PLT";
1823     case DT_AARCH64_VARIANT_PCS:  return "AARCH64_VARIANT_PCS";
1824     default:
1825       return NULL;
1826     }
1827 }
1828
1829 static const char *
1830 get_mips_dynamic_type (unsigned long type)
1831 {
1832   switch (type)
1833     {
1834     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1835     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1836     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1837     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1838     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1839     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1840     case DT_MIPS_MSYM: return "MIPS_MSYM";
1841     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1842     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1843     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1844     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1845     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1846     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1847     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1848     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1849     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1850     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1851     case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1852     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1853     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1854     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1855     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1856     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1857     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1858     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1859     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1860     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1861     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1862     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1863     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1864     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1865     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1866     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1867     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1868     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1869     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1870     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1871     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1872     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1873     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1874     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1875     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1876     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1877     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1878     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1879     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1880     case DT_MIPS_XHASH: return "MIPS_XHASH";
1881     default:
1882       return NULL;
1883     }
1884 }
1885
1886 static const char *
1887 get_sparc64_dynamic_type (unsigned long type)
1888 {
1889   switch (type)
1890     {
1891     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1892     default:
1893       return NULL;
1894     }
1895 }
1896
1897 static const char *
1898 get_ppc_dynamic_type (unsigned long type)
1899 {
1900   switch (type)
1901     {
1902     case DT_PPC_GOT:    return "PPC_GOT";
1903     case DT_PPC_OPT:    return "PPC_OPT";
1904     default:
1905       return NULL;
1906     }
1907 }
1908
1909 static const char *
1910 get_ppc64_dynamic_type (unsigned long type)
1911 {
1912   switch (type)
1913     {
1914     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1915     case DT_PPC64_OPD:    return "PPC64_OPD";
1916     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1917     case DT_PPC64_OPT:    return "PPC64_OPT";
1918     default:
1919       return NULL;
1920     }
1921 }
1922
1923 static const char *
1924 get_parisc_dynamic_type (unsigned long type)
1925 {
1926   switch (type)
1927     {
1928     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1929     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1930     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1931     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1932     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1933     case DT_HP_PREINIT:         return "HP_PREINIT";
1934     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1935     case DT_HP_NEEDED:          return "HP_NEEDED";
1936     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1937     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1938     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1939     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1940     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1941     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1942     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1943     case DT_HP_FILTERED:        return "HP_FILTERED";
1944     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1945     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1946     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1947     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1948     case DT_PLT:                return "PLT";
1949     case DT_PLT_SIZE:           return "PLT_SIZE";
1950     case DT_DLT:                return "DLT";
1951     case DT_DLT_SIZE:           return "DLT_SIZE";
1952     default:
1953       return NULL;
1954     }
1955 }
1956
1957 static const char *
1958 get_ia64_dynamic_type (unsigned long type)
1959 {
1960   switch (type)
1961     {
1962     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1963     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1964     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1965     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1966     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1967     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1968     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1969     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1970     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1971     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1972     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1973     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1974     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1975     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1976     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1977     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1978     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1979     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1980     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1981     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1982     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1983     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1984     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1985     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1986     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1987     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1988     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1989     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1990     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1991     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1992     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1993     default:
1994       return NULL;
1995     }
1996 }
1997
1998 static const char *
1999 get_solaris_section_type (unsigned long type)
2000 {
2001   switch (type)
2002     {
2003     case 0x6fffffee: return "SUNW_ancillary";
2004     case 0x6fffffef: return "SUNW_capchain";
2005     case 0x6ffffff0: return "SUNW_capinfo";
2006     case 0x6ffffff1: return "SUNW_symsort";
2007     case 0x6ffffff2: return "SUNW_tlssort";
2008     case 0x6ffffff3: return "SUNW_LDYNSYM";
2009     case 0x6ffffff4: return "SUNW_dof";
2010     case 0x6ffffff5: return "SUNW_cap";
2011     case 0x6ffffff6: return "SUNW_SIGNATURE";
2012     case 0x6ffffff7: return "SUNW_ANNOTATE";
2013     case 0x6ffffff8: return "SUNW_DEBUGSTR";
2014     case 0x6ffffff9: return "SUNW_DEBUG";
2015     case 0x6ffffffa: return "SUNW_move";
2016     case 0x6ffffffb: return "SUNW_COMDAT";
2017     case 0x6ffffffc: return "SUNW_syminfo";
2018     case 0x6ffffffd: return "SUNW_verdef";
2019     case 0x6ffffffe: return "SUNW_verneed";
2020     case 0x6fffffff: return "SUNW_versym";
2021     case 0x70000000: return "SPARC_GOTDATA";
2022     default: return NULL;
2023     }
2024 }
2025
2026 static const char *
2027 get_alpha_dynamic_type (unsigned long type)
2028 {
2029   switch (type)
2030     {
2031     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
2032     default: return NULL;
2033     }
2034 }
2035
2036 static const char *
2037 get_score_dynamic_type (unsigned long type)
2038 {
2039   switch (type)
2040     {
2041     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
2042     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
2043     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
2044     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
2045     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
2046     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
2047     default:                    return NULL;
2048     }
2049 }
2050
2051 static const char *
2052 get_tic6x_dynamic_type (unsigned long type)
2053 {
2054   switch (type)
2055     {
2056     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
2057     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
2058     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
2059     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
2060     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
2061     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
2062     default:                   return NULL;
2063     }
2064 }
2065
2066 static const char *
2067 get_nios2_dynamic_type (unsigned long type)
2068 {
2069   switch (type)
2070     {
2071     case DT_NIOS2_GP: return "NIOS2_GP";
2072     default:          return NULL;
2073     }
2074 }
2075
2076 static const char *
2077 get_solaris_dynamic_type (unsigned long type)
2078 {
2079   switch (type)
2080     {
2081     case 0x6000000d: return "SUNW_AUXILIARY";
2082     case 0x6000000e: return "SUNW_RTLDINF";
2083     case 0x6000000f: return "SUNW_FILTER";
2084     case 0x60000010: return "SUNW_CAP";
2085     case 0x60000011: return "SUNW_SYMTAB";
2086     case 0x60000012: return "SUNW_SYMSZ";
2087     case 0x60000013: return "SUNW_SORTENT";
2088     case 0x60000014: return "SUNW_SYMSORT";
2089     case 0x60000015: return "SUNW_SYMSORTSZ";
2090     case 0x60000016: return "SUNW_TLSSORT";
2091     case 0x60000017: return "SUNW_TLSSORTSZ";
2092     case 0x60000018: return "SUNW_CAPINFO";
2093     case 0x60000019: return "SUNW_STRPAD";
2094     case 0x6000001a: return "SUNW_CAPCHAIN";
2095     case 0x6000001b: return "SUNW_LDMACH";
2096     case 0x6000001d: return "SUNW_CAPCHAINENT";
2097     case 0x6000001f: return "SUNW_CAPCHAINSZ";
2098     case 0x60000021: return "SUNW_PARENT";
2099     case 0x60000023: return "SUNW_ASLR";
2100     case 0x60000025: return "SUNW_RELAX";
2101     case 0x60000029: return "SUNW_NXHEAP";
2102     case 0x6000002b: return "SUNW_NXSTACK";
2103
2104     case 0x70000001: return "SPARC_REGISTER";
2105     case 0x7ffffffd: return "AUXILIARY";
2106     case 0x7ffffffe: return "USED";
2107     case 0x7fffffff: return "FILTER";
2108
2109     default: return NULL;
2110     }
2111 }
2112
2113 static const char *
2114 get_dynamic_type (Filedata * filedata, unsigned long type)
2115 {
2116   static char buff[64];
2117
2118   switch (type)
2119     {
2120     case DT_NULL:       return "NULL";
2121     case DT_NEEDED:     return "NEEDED";
2122     case DT_PLTRELSZ:   return "PLTRELSZ";
2123     case DT_PLTGOT:     return "PLTGOT";
2124     case DT_HASH:       return "HASH";
2125     case DT_STRTAB:     return "STRTAB";
2126     case DT_SYMTAB:     return "SYMTAB";
2127     case DT_RELA:       return "RELA";
2128     case DT_RELASZ:     return "RELASZ";
2129     case DT_RELAENT:    return "RELAENT";
2130     case DT_STRSZ:      return "STRSZ";
2131     case DT_SYMENT:     return "SYMENT";
2132     case DT_INIT:       return "INIT";
2133     case DT_FINI:       return "FINI";
2134     case DT_SONAME:     return "SONAME";
2135     case DT_RPATH:      return "RPATH";
2136     case DT_SYMBOLIC:   return "SYMBOLIC";
2137     case DT_REL:        return "REL";
2138     case DT_RELSZ:      return "RELSZ";
2139     case DT_RELENT:     return "RELENT";
2140     case DT_PLTREL:     return "PLTREL";
2141     case DT_DEBUG:      return "DEBUG";
2142     case DT_TEXTREL:    return "TEXTREL";
2143     case DT_JMPREL:     return "JMPREL";
2144     case DT_BIND_NOW:   return "BIND_NOW";
2145     case DT_INIT_ARRAY: return "INIT_ARRAY";
2146     case DT_FINI_ARRAY: return "FINI_ARRAY";
2147     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2148     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2149     case DT_RUNPATH:    return "RUNPATH";
2150     case DT_FLAGS:      return "FLAGS";
2151
2152     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2153     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2154     case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2155
2156     case DT_CHECKSUM:   return "CHECKSUM";
2157     case DT_PLTPADSZ:   return "PLTPADSZ";
2158     case DT_MOVEENT:    return "MOVEENT";
2159     case DT_MOVESZ:     return "MOVESZ";
2160     case DT_FEATURE:    return "FEATURE";
2161     case DT_POSFLAG_1:  return "POSFLAG_1";
2162     case DT_SYMINSZ:    return "SYMINSZ";
2163     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
2164
2165     case DT_ADDRRNGLO:  return "ADDRRNGLO";
2166     case DT_CONFIG:     return "CONFIG";
2167     case DT_DEPAUDIT:   return "DEPAUDIT";
2168     case DT_AUDIT:      return "AUDIT";
2169     case DT_PLTPAD:     return "PLTPAD";
2170     case DT_MOVETAB:    return "MOVETAB";
2171     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
2172
2173     case DT_VERSYM:     return "VERSYM";
2174
2175     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2176     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2177     case DT_RELACOUNT:  return "RELACOUNT";
2178     case DT_RELCOUNT:   return "RELCOUNT";
2179     case DT_FLAGS_1:    return "FLAGS_1";
2180     case DT_VERDEF:     return "VERDEF";
2181     case DT_VERDEFNUM:  return "VERDEFNUM";
2182     case DT_VERNEED:    return "VERNEED";
2183     case DT_VERNEEDNUM: return "VERNEEDNUM";
2184
2185     case DT_AUXILIARY:  return "AUXILIARY";
2186     case DT_USED:       return "USED";
2187     case DT_FILTER:     return "FILTER";
2188
2189     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2190     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2191     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2192     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2193     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2194     case DT_GNU_HASH:   return "GNU_HASH";
2195
2196     default:
2197       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2198         {
2199           const char * result;
2200
2201           switch (filedata->file_header.e_machine)
2202             {
2203             case EM_AARCH64:
2204               result = get_aarch64_dynamic_type (type);
2205               break;
2206             case EM_MIPS:
2207             case EM_MIPS_RS3_LE:
2208               result = get_mips_dynamic_type (type);
2209               break;
2210             case EM_SPARCV9:
2211               result = get_sparc64_dynamic_type (type);
2212               break;
2213             case EM_PPC:
2214               result = get_ppc_dynamic_type (type);
2215               break;
2216             case EM_PPC64:
2217               result = get_ppc64_dynamic_type (type);
2218               break;
2219             case EM_IA_64:
2220               result = get_ia64_dynamic_type (type);
2221               break;
2222             case EM_ALPHA:
2223               result = get_alpha_dynamic_type (type);
2224               break;
2225             case EM_SCORE:
2226               result = get_score_dynamic_type (type);
2227               break;
2228             case EM_TI_C6000:
2229               result = get_tic6x_dynamic_type (type);
2230               break;
2231             case EM_ALTERA_NIOS2:
2232               result = get_nios2_dynamic_type (type);
2233               break;
2234             default:
2235               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2236                 result = get_solaris_dynamic_type (type);
2237               else
2238                 result = NULL;
2239               break;
2240             }
2241
2242           if (result != NULL)
2243             return result;
2244
2245           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2246         }
2247       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2248                || (filedata->file_header.e_machine == EM_PARISC
2249                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2250         {
2251           const char * result;
2252
2253           switch (filedata->file_header.e_machine)
2254             {
2255             case EM_PARISC:
2256               result = get_parisc_dynamic_type (type);
2257               break;
2258             case EM_IA_64:
2259               result = get_ia64_dynamic_type (type);
2260               break;
2261             default:
2262               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2263                 result = get_solaris_dynamic_type (type);
2264               else
2265                 result = NULL;
2266               break;
2267             }
2268
2269           if (result != NULL)
2270             return result;
2271
2272           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2273                     type);
2274         }
2275       else
2276         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2277
2278       return buff;
2279     }
2280 }
2281
2282 static char *
2283 get_file_type (unsigned e_type)
2284 {
2285   static char buff[32];
2286
2287   switch (e_type)
2288     {
2289     case ET_NONE: return _("NONE (None)");
2290     case ET_REL:  return _("REL (Relocatable file)");
2291     case ET_EXEC: return _("EXEC (Executable file)");
2292     case ET_DYN:  return _("DYN (Shared object file)");
2293     case ET_CORE: return _("CORE (Core file)");
2294
2295     default:
2296       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2297         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2298       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2299         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2300       else
2301         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2302       return buff;
2303     }
2304 }
2305
2306 static char *
2307 get_machine_name (unsigned e_machine)
2308 {
2309   static char buff[64]; /* XXX */
2310
2311   switch (e_machine)
2312     {
2313       /* Please keep this switch table sorted by increasing EM_ value.  */
2314       /* 0 */
2315     case EM_NONE:               return _("None");
2316     case EM_M32:                return "WE32100";
2317     case EM_SPARC:              return "Sparc";
2318     case EM_386:                return "Intel 80386";
2319     case EM_68K:                return "MC68000";
2320     case EM_88K:                return "MC88000";
2321     case EM_IAMCU:              return "Intel MCU";
2322     case EM_860:                return "Intel 80860";
2323     case EM_MIPS:               return "MIPS R3000";
2324     case EM_S370:               return "IBM System/370";
2325       /* 10 */
2326     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
2327     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
2328     case EM_PARISC:             return "HPPA";
2329     case EM_VPP550:             return "Fujitsu VPP500";
2330     case EM_SPARC32PLUS:        return "Sparc v8+" ;
2331     case EM_960:                return "Intel 80960";
2332     case EM_PPC:                return "PowerPC";
2333       /* 20 */
2334     case EM_PPC64:              return "PowerPC64";
2335     case EM_S390_OLD:
2336     case EM_S390:               return "IBM S/390";
2337     case EM_SPU:                return "SPU";
2338       /* 30 */
2339     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
2340     case EM_FR20:               return "Fujitsu FR20";
2341     case EM_RH32:               return "TRW RH32";
2342     case EM_MCORE:              return "MCORE";
2343       /* 40 */
2344     case EM_ARM:                return "ARM";
2345     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
2346     case EM_SH:                 return "Renesas / SuperH SH";
2347     case EM_SPARCV9:            return "Sparc v9";
2348     case EM_TRICORE:            return "Siemens Tricore";
2349     case EM_ARC:                return "ARC";
2350     case EM_H8_300:             return "Renesas H8/300";
2351     case EM_H8_300H:            return "Renesas H8/300H";
2352     case EM_H8S:                return "Renesas H8S";
2353     case EM_H8_500:             return "Renesas H8/500";
2354       /* 50 */
2355     case EM_IA_64:              return "Intel IA-64";
2356     case EM_MIPS_X:             return "Stanford MIPS-X";
2357     case EM_COLDFIRE:           return "Motorola Coldfire";
2358     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
2359     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
2360     case EM_PCP:                return "Siemens PCP";
2361     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
2362     case EM_NDR1:               return "Denso NDR1 microprocesspr";
2363     case EM_STARCORE:           return "Motorola Star*Core processor";
2364     case EM_ME16:               return "Toyota ME16 processor";
2365       /* 60 */
2366     case EM_ST100:              return "STMicroelectronics ST100 processor";
2367     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
2368     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2369     case EM_PDSP:               return "Sony DSP processor";
2370     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
2371     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
2372     case EM_FX66:               return "Siemens FX66 microcontroller";
2373     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2374     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
2375     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
2376       /* 70 */
2377     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
2378     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
2379     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
2380     case EM_SVX:                return "Silicon Graphics SVx";
2381     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
2382     case EM_VAX:                return "Digital VAX";
2383     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
2384     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
2385     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2386     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2387       /* 80 */
2388     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2389     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2390     case EM_PRISM:              return "Vitesse Prism";
2391     case EM_AVR_OLD:
2392     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
2393     case EM_CYGNUS_FR30:
2394     case EM_FR30:               return "Fujitsu FR30";
2395     case EM_CYGNUS_D10V:
2396     case EM_D10V:               return "d10v";
2397     case EM_CYGNUS_D30V:
2398     case EM_D30V:               return "d30v";
2399     case EM_CYGNUS_V850:
2400     case EM_V850:               return "Renesas V850";
2401     case EM_CYGNUS_M32R:
2402     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
2403     case EM_CYGNUS_MN10300:
2404     case EM_MN10300:            return "mn10300";
2405       /* 90 */
2406     case EM_CYGNUS_MN10200:
2407     case EM_MN10200:            return "mn10200";
2408     case EM_PJ:                 return "picoJava";
2409     case EM_OR1K:               return "OpenRISC 1000";
2410     case EM_ARC_COMPACT:        return "ARCompact";
2411     case EM_XTENSA_OLD:
2412     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2413     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2414     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2415     case EM_NS32K:              return "National Semiconductor 32000 series";
2416     case EM_TPC:                return "Tenor Network TPC processor";
2417     case EM_SNP1K:              return "Trebia SNP 1000 processor";
2418       /* 100 */
2419     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2420     case EM_IP2K_OLD:
2421     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2422     case EM_MAX:                return "MAX Processor";
2423     case EM_CR:                 return "National Semiconductor CompactRISC";
2424     case EM_F2MC16:             return "Fujitsu F2MC16";
2425     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2426     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2427     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2428     case EM_SEP:                return "Sharp embedded microprocessor";
2429     case EM_ARCA:               return "Arca RISC microprocessor";
2430       /* 110 */
2431     case EM_UNICORE:            return "Unicore";
2432     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2433     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2434     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2435     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2436     case EM_XGATE:              return "Motorola XGATE embedded processor";
2437     case EM_C166:
2438     case EM_XC16X:              return "Infineon Technologies xc16x";
2439     case EM_M16C:               return "Renesas M16C series microprocessors";
2440     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2441     case EM_CE:                 return "Freescale Communication Engine RISC core";
2442       /* 120 */
2443     case EM_M32C:               return "Renesas M32c";
2444       /* 130 */
2445     case EM_TSK3000:            return "Altium TSK3000 core";
2446     case EM_RS08:               return "Freescale RS08 embedded processor";
2447     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2448     case EM_SCORE:              return "SUNPLUS S+Core";
2449     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2450     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2451     case EM_LATTICEMICO32:      return "Lattice Mico32";
2452     case EM_SE_C17:             return "Seiko Epson C17 family";
2453       /* 140 */
2454     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2455     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2456     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2457     case EM_TI_PRU:             return "TI PRU I/O processor";
2458       /* 160 */
2459     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2460     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2461     case EM_R32C:               return "Renesas R32C series microprocessors";
2462     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2463     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2464     case EM_8051:               return "Intel 8051 and variants";
2465     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2466     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2467     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2468     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2469       /* 170 */
2470     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2471     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2472     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2473     case EM_RX:                 return "Renesas RX";
2474     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2475     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2476     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2477     case EM_CR16:
2478     case EM_MICROBLAZE:
2479     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2480     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2481     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2482       /* 180 */
2483     case EM_L1OM:               return "Intel L1OM";
2484     case EM_K1OM:               return "Intel K1OM";
2485     case EM_INTEL182:           return "Intel (reserved)";
2486     case EM_AARCH64:            return "AArch64";
2487     case EM_ARM184:             return "ARM (reserved)";
2488     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor";
2489     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2490     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2491     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2492       /* 190 */
2493     case EM_CUDA:               return "NVIDIA CUDA architecture";
2494     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2495     case EM_CLOUDSHIELD:        return "CloudShield architecture family";
2496     case EM_COREA_1ST:          return "KIPO-KAIST Core-A 1st generation processor family";
2497     case EM_COREA_2ND:          return "KIPO-KAIST Core-A 2nd generation processor family";
2498     case EM_ARC_COMPACT2:       return "ARCv2";
2499     case EM_OPEN8:              return "Open8 8-bit RISC soft processor core";
2500     case EM_RL78:               return "Renesas RL78";
2501     case EM_VIDEOCORE5:         return "Broadcom VideoCore V processor";
2502     case EM_78K0R:              return "Renesas 78K0R";
2503       /* 200 */
2504     case EM_56800EX:            return "Freescale 56800EX Digital Signal Controller (DSC)";
2505     case EM_BA1:                return "Beyond BA1 CPU architecture";
2506     case EM_BA2:                return "Beyond BA2 CPU architecture";
2507     case EM_XCORE:              return "XMOS xCORE processor family";
2508     case EM_MCHP_PIC:           return "Microchip 8-bit PIC(r) family";
2509       /* 210 */
2510     case EM_KM32:               return "KM211 KM32 32-bit processor";
2511     case EM_KMX32:              return "KM211 KMX32 32-bit processor";
2512     case EM_KMX16:              return "KM211 KMX16 16-bit processor";
2513     case EM_KMX8:               return "KM211 KMX8 8-bit processor";
2514     case EM_KVARC:              return "KM211 KVARC processor";
2515     case EM_CDP:                return "Paneve CDP architecture family";
2516     case EM_COGE:               return "Cognitive Smart Memory Processor";
2517     case EM_COOL:               return "Bluechip Systems CoolEngine";
2518     case EM_NORC:               return "Nanoradio Optimized RISC";
2519     case EM_CSR_KALIMBA:        return "CSR Kalimba architecture family";
2520       /* 220 */
2521     case EM_Z80:                return "Zilog Z80";
2522     case EM_VISIUM:             return "CDS VISIUMcore processor";
2523     case EM_FT32:               return "FTDI Chip FT32";
2524     case EM_MOXIE:              return "Moxie";
2525     case EM_AMDGPU:             return "AMD GPU";
2526     case EM_RISCV:              return "RISC-V";
2527     case EM_LANAI:              return "Lanai 32-bit processor";
2528     case EM_BPF:                return "Linux BPF";
2529     case EM_NFP:                return "Netronome Flow Processor";
2530
2531       /* Large numbers...  */
2532     case EM_MT:                 return "Morpho Techologies MT processor";
2533     case EM_ALPHA:              return "Alpha";
2534     case EM_WEBASSEMBLY:        return "Web Assembly";
2535     case EM_DLX:                return "OpenDLX";
2536     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2537     case EM_IQ2000:             return "Vitesse IQ2000";
2538     case EM_M32C_OLD:
2539     case EM_NIOS32:             return "Altera Nios";
2540     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2541     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2542     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
2543     case EM_S12Z:               return "Freescale S12Z";
2544     case EM_CSKY:               return "C-SKY";
2545
2546     default:
2547       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2548       return buff;
2549     }
2550 }
2551
2552 static void
2553 decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2554 {
2555   /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2.  Some
2556      other compilers don't a specific architecture type in the e_flags, and
2557      instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2558      architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2559      architectures.
2560
2561      Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2562      but also sets a specific architecture type in the e_flags field.
2563
2564      However, when decoding the flags we don't worry if we see an
2565      unexpected pairing, for example EM_ARC_COMPACT machine type, with
2566      ARCEM architecture type.  */
2567
2568   switch (e_flags & EF_ARC_MACH_MSK)
2569     {
2570       /* We only expect these to occur for EM_ARC_COMPACT2.  */
2571     case EF_ARC_CPU_ARCV2EM:
2572       strcat (buf, ", ARC EM");
2573       break;
2574     case EF_ARC_CPU_ARCV2HS:
2575       strcat (buf, ", ARC HS");
2576       break;
2577
2578       /* We only expect these to occur for EM_ARC_COMPACT.  */
2579     case E_ARC_MACH_ARC600:
2580       strcat (buf, ", ARC600");
2581       break;
2582     case E_ARC_MACH_ARC601:
2583       strcat (buf, ", ARC601");
2584       break;
2585     case E_ARC_MACH_ARC700:
2586       strcat (buf, ", ARC700");
2587       break;
2588
2589       /* The only times we should end up here are (a) A corrupt ELF, (b) A
2590          new ELF with new architecture being read by an old version of
2591          readelf, or (c) An ELF built with non-GNU compiler that does not
2592          set the architecture in the e_flags.  */
2593     default:
2594       if (e_machine == EM_ARC_COMPACT)
2595         strcat (buf, ", Unknown ARCompact");
2596       else
2597         strcat (buf, ", Unknown ARC");
2598       break;
2599     }
2600
2601   switch (e_flags & EF_ARC_OSABI_MSK)
2602     {
2603     case E_ARC_OSABI_ORIG:
2604       strcat (buf, ", (ABI:legacy)");
2605       break;
2606     case E_ARC_OSABI_V2:
2607       strcat (buf, ", (ABI:v2)");
2608       break;
2609       /* Only upstream 3.9+ kernels will support ARCv2 ISA.  */
2610     case E_ARC_OSABI_V3:
2611       strcat (buf, ", v3 no-legacy-syscalls ABI");
2612       break;
2613     case E_ARC_OSABI_V4:
2614       strcat (buf, ", v4 ABI");
2615       break;
2616     default:
2617       strcat (buf, ", unrecognised ARC OSABI flag");
2618       break;
2619     }
2620 }
2621
2622 static void
2623 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2624 {
2625   unsigned eabi;
2626   bfd_boolean unknown = FALSE;
2627
2628   eabi = EF_ARM_EABI_VERSION (e_flags);
2629   e_flags &= ~ EF_ARM_EABIMASK;
2630
2631   /* Handle "generic" ARM flags.  */
2632   if (e_flags & EF_ARM_RELEXEC)
2633     {
2634       strcat (buf, ", relocatable executable");
2635       e_flags &= ~ EF_ARM_RELEXEC;
2636     }
2637
2638   if (e_flags & EF_ARM_PIC)
2639     {
2640       strcat (buf, ", position independent");
2641       e_flags &= ~ EF_ARM_PIC;
2642     }
2643
2644   /* Now handle EABI specific flags.  */
2645   switch (eabi)
2646     {
2647     default:
2648       strcat (buf, ", <unrecognized EABI>");
2649       if (e_flags)
2650         unknown = TRUE;
2651       break;
2652
2653     case EF_ARM_EABI_VER1:
2654       strcat (buf, ", Version1 EABI");
2655       while (e_flags)
2656         {
2657           unsigned flag;
2658
2659           /* Process flags one bit at a time.  */
2660           flag = e_flags & - e_flags;
2661           e_flags &= ~ flag;
2662
2663           switch (flag)
2664             {
2665             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2666               strcat (buf, ", sorted symbol tables");
2667               break;
2668
2669             default:
2670               unknown = TRUE;
2671               break;
2672             }
2673         }
2674       break;
2675
2676     case EF_ARM_EABI_VER2:
2677       strcat (buf, ", Version2 EABI");
2678       while (e_flags)
2679         {
2680           unsigned flag;
2681
2682           /* Process flags one bit at a time.  */
2683           flag = e_flags & - e_flags;
2684           e_flags &= ~ flag;
2685
2686           switch (flag)
2687             {
2688             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2689               strcat (buf, ", sorted symbol tables");
2690               break;
2691
2692             case EF_ARM_DYNSYMSUSESEGIDX:
2693               strcat (buf, ", dynamic symbols use segment index");
2694               break;
2695
2696             case EF_ARM_MAPSYMSFIRST:
2697               strcat (buf, ", mapping symbols precede others");
2698               break;
2699
2700             default:
2701               unknown = TRUE;
2702               break;
2703             }
2704         }
2705       break;
2706
2707     case EF_ARM_EABI_VER3:
2708       strcat (buf, ", Version3 EABI");
2709       break;
2710
2711     case EF_ARM_EABI_VER4:
2712       strcat (buf, ", Version4 EABI");
2713       while (e_flags)
2714         {
2715           unsigned flag;
2716
2717           /* Process flags one bit at a time.  */
2718           flag = e_flags & - e_flags;
2719           e_flags &= ~ flag;
2720
2721           switch (flag)
2722             {
2723             case EF_ARM_BE8:
2724               strcat (buf, ", BE8");
2725               break;
2726
2727             case EF_ARM_LE8:
2728               strcat (buf, ", LE8");
2729               break;
2730
2731             default:
2732               unknown = TRUE;
2733               break;
2734             }
2735         }
2736       break;
2737
2738     case EF_ARM_EABI_VER5:
2739       strcat (buf, ", Version5 EABI");
2740       while (e_flags)
2741         {
2742           unsigned flag;
2743
2744           /* Process flags one bit at a time.  */
2745           flag = e_flags & - e_flags;
2746           e_flags &= ~ flag;
2747
2748           switch (flag)
2749             {
2750             case EF_ARM_BE8:
2751               strcat (buf, ", BE8");
2752               break;
2753
2754             case EF_ARM_LE8:
2755               strcat (buf, ", LE8");
2756               break;
2757
2758             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2759               strcat (buf, ", soft-float ABI");
2760               break;
2761
2762             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2763               strcat (buf, ", hard-float ABI");
2764               break;
2765
2766             default:
2767               unknown = TRUE;
2768               break;
2769             }
2770         }
2771       break;
2772
2773     case EF_ARM_EABI_UNKNOWN:
2774       strcat (buf, ", GNU EABI");
2775       while (e_flags)
2776         {
2777           unsigned flag;
2778
2779           /* Process flags one bit at a time.  */
2780           flag = e_flags & - e_flags;
2781           e_flags &= ~ flag;
2782
2783           switch (flag)
2784             {
2785             case EF_ARM_INTERWORK:
2786               strcat (buf, ", interworking enabled");
2787               break;
2788
2789             case EF_ARM_APCS_26:
2790               strcat (buf, ", uses APCS/26");
2791               break;
2792
2793             case EF_ARM_APCS_FLOAT:
2794               strcat (buf, ", uses APCS/float");
2795               break;
2796
2797             case EF_ARM_PIC:
2798               strcat (buf, ", position independent");
2799               break;
2800
2801             case EF_ARM_ALIGN8:
2802               strcat (buf, ", 8 bit structure alignment");
2803               break;
2804
2805             case EF_ARM_NEW_ABI:
2806               strcat (buf, ", uses new ABI");
2807               break;
2808
2809             case EF_ARM_OLD_ABI:
2810               strcat (buf, ", uses old ABI");
2811               break;
2812
2813             case EF_ARM_SOFT_FLOAT:
2814               strcat (buf, ", software FP");
2815               break;
2816
2817             case EF_ARM_VFP_FLOAT:
2818               strcat (buf, ", VFP");
2819               break;
2820
2821             case EF_ARM_MAVERICK_FLOAT:
2822               strcat (buf, ", Maverick FP");
2823               break;
2824
2825             default:
2826               unknown = TRUE;
2827               break;
2828             }
2829         }
2830     }
2831
2832   if (unknown)
2833     strcat (buf,_(", <unknown>"));
2834 }
2835
2836 static void
2837 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2838 {
2839   --size; /* Leave space for null terminator.  */
2840
2841   switch (e_flags & EF_AVR_MACH)
2842     {
2843     case E_AVR_MACH_AVR1:
2844       strncat (buf, ", avr:1", size);
2845       break;
2846     case E_AVR_MACH_AVR2:
2847       strncat (buf, ", avr:2", size);
2848       break;
2849     case E_AVR_MACH_AVR25:
2850       strncat (buf, ", avr:25", size);
2851       break;
2852     case E_AVR_MACH_AVR3:
2853       strncat (buf, ", avr:3", size);
2854       break;
2855     case E_AVR_MACH_AVR31:
2856       strncat (buf, ", avr:31", size);
2857       break;
2858     case E_AVR_MACH_AVR35:
2859       strncat (buf, ", avr:35", size);
2860       break;
2861     case E_AVR_MACH_AVR4:
2862       strncat (buf, ", avr:4", size);
2863       break;
2864     case E_AVR_MACH_AVR5:
2865       strncat (buf, ", avr:5", size);
2866       break;
2867     case E_AVR_MACH_AVR51:
2868       strncat (buf, ", avr:51", size);
2869       break;
2870     case E_AVR_MACH_AVR6:
2871       strncat (buf, ", avr:6", size);
2872       break;
2873     case E_AVR_MACH_AVRTINY:
2874       strncat (buf, ", avr:100", size);
2875       break;
2876     case E_AVR_MACH_XMEGA1:
2877       strncat (buf, ", avr:101", size);
2878       break;
2879     case E_AVR_MACH_XMEGA2:
2880       strncat (buf, ", avr:102", size);
2881       break;
2882     case E_AVR_MACH_XMEGA3:
2883       strncat (buf, ", avr:103", size);
2884       break;
2885     case E_AVR_MACH_XMEGA4:
2886       strncat (buf, ", avr:104", size);
2887       break;
2888     case E_AVR_MACH_XMEGA5:
2889       strncat (buf, ", avr:105", size);
2890       break;
2891     case E_AVR_MACH_XMEGA6:
2892       strncat (buf, ", avr:106", size);
2893       break;
2894     case E_AVR_MACH_XMEGA7:
2895       strncat (buf, ", avr:107", size);
2896       break;
2897     default:
2898       strncat (buf, ", avr:<unknown>", size);
2899       break;
2900     }
2901
2902   size -= strlen (buf);
2903   if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2904     strncat (buf, ", link-relax", size);
2905 }
2906
2907 static void
2908 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2909 {
2910   unsigned abi;
2911   unsigned arch;
2912   unsigned config;
2913   unsigned version;
2914   bfd_boolean has_fpu = FALSE;
2915   unsigned int r = 0;
2916
2917   static const char *ABI_STRINGS[] =
2918   {
2919     "ABI v0", /* use r5 as return register; only used in N1213HC */
2920     "ABI v1", /* use r0 as return register */
2921     "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2922     "ABI v2fp", /* for FPU */
2923     "AABI",
2924     "ABI2 FP+"
2925   };
2926   static const char *VER_STRINGS[] =
2927   {
2928     "Andes ELF V1.3 or older",
2929     "Andes ELF V1.3.1",
2930     "Andes ELF V1.4"
2931   };
2932   static const char *ARCH_STRINGS[] =
2933   {
2934     "",
2935     "Andes Star v1.0",
2936     "Andes Star v2.0",
2937     "Andes Star v3.0",
2938     "Andes Star v3.0m"
2939   };
2940
2941   abi = EF_NDS_ABI & e_flags;
2942   arch = EF_NDS_ARCH & e_flags;
2943   config = EF_NDS_INST & e_flags;
2944   version = EF_NDS32_ELF_VERSION & e_flags;
2945
2946   memset (buf, 0, size);
2947
2948   switch (abi)
2949     {
2950     case E_NDS_ABI_V0:
2951     case E_NDS_ABI_V1:
2952     case E_NDS_ABI_V2:
2953     case E_NDS_ABI_V2FP:
2954     case E_NDS_ABI_AABI:
2955     case E_NDS_ABI_V2FP_PLUS:
2956       /* In case there are holes in the array.  */
2957       r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2958       break;
2959
2960     default:
2961       r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2962       break;
2963     }
2964
2965   switch (version)
2966     {
2967     case E_NDS32_ELF_VER_1_2:
2968     case E_NDS32_ELF_VER_1_3:
2969     case E_NDS32_ELF_VER_1_4:
2970       r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2971       break;
2972
2973     default:
2974       r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2975       break;
2976     }
2977
2978   if (E_NDS_ABI_V0 == abi)
2979     {
2980       /* OLD ABI; only used in N1213HC, has performance extension 1.  */
2981       r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2982       if (arch == E_NDS_ARCH_STAR_V1_0)
2983         r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2984       return;
2985     }
2986
2987   switch (arch)
2988     {
2989     case E_NDS_ARCH_STAR_V1_0:
2990     case E_NDS_ARCH_STAR_V2_0:
2991     case E_NDS_ARCH_STAR_V3_0:
2992     case E_NDS_ARCH_STAR_V3_M:
2993       r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2994       break;
2995
2996     default:
2997       r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2998       /* ARCH version determines how the e_flags are interpreted.
2999          If it is unknown, we cannot proceed.  */
3000       return;
3001     }
3002
3003   /* Newer ABI; Now handle architecture specific flags.  */
3004   if (arch == E_NDS_ARCH_STAR_V1_0)
3005     {
3006       if (config & E_NDS32_HAS_MFUSR_PC_INST)
3007         r += snprintf (buf + r, size -r, ", MFUSR_PC");
3008
3009       if (!(config & E_NDS32_HAS_NO_MAC_INST))
3010         r += snprintf (buf + r, size -r, ", MAC");
3011
3012       if (config & E_NDS32_HAS_DIV_INST)
3013         r += snprintf (buf + r, size -r, ", DIV");
3014
3015       if (config & E_NDS32_HAS_16BIT_INST)
3016         r += snprintf (buf + r, size -r, ", 16b");
3017     }
3018   else
3019     {
3020       if (config & E_NDS32_HAS_MFUSR_PC_INST)
3021         {
3022           if (version <= E_NDS32_ELF_VER_1_3)
3023             r += snprintf (buf + r, size -r, ", [B8]");
3024           else
3025             r += snprintf (buf + r, size -r, ", EX9");
3026         }
3027
3028       if (config & E_NDS32_HAS_MAC_DX_INST)
3029         r += snprintf (buf + r, size -r, ", MAC_DX");
3030
3031       if (config & E_NDS32_HAS_DIV_DX_INST)
3032         r += snprintf (buf + r, size -r, ", DIV_DX");
3033
3034       if (config & E_NDS32_HAS_16BIT_INST)
3035         {
3036           if (version <= E_NDS32_ELF_VER_1_3)
3037             r += snprintf (buf + r, size -r, ", 16b");
3038           else
3039             r += snprintf (buf + r, size -r, ", IFC");
3040         }
3041     }
3042
3043   if (config & E_NDS32_HAS_EXT_INST)
3044     r += snprintf (buf + r, size -r, ", PERF1");
3045
3046   if (config & E_NDS32_HAS_EXT2_INST)
3047     r += snprintf (buf + r, size -r, ", PERF2");
3048
3049   if (config & E_NDS32_HAS_FPU_INST)
3050     {
3051       has_fpu = TRUE;
3052       r += snprintf (buf + r, size -r, ", FPU_SP");
3053     }
3054
3055   if (config & E_NDS32_HAS_FPU_DP_INST)
3056     {
3057       has_fpu = TRUE;
3058       r += snprintf (buf + r, size -r, ", FPU_DP");
3059     }
3060
3061   if (config & E_NDS32_HAS_FPU_MAC_INST)
3062     {
3063       has_fpu = TRUE;
3064       r += snprintf (buf + r, size -r, ", FPU_MAC");
3065     }
3066
3067   if (has_fpu)
3068     {
3069       switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
3070         {
3071         case E_NDS32_FPU_REG_8SP_4DP:
3072           r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
3073           break;
3074         case E_NDS32_FPU_REG_16SP_8DP:
3075           r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
3076           break;
3077         case E_NDS32_FPU_REG_32SP_16DP:
3078           r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
3079           break;
3080         case E_NDS32_FPU_REG_32SP_32DP:
3081           r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
3082           break;
3083         }
3084     }
3085
3086   if (config & E_NDS32_HAS_AUDIO_INST)
3087     r += snprintf (buf + r, size -r, ", AUDIO");
3088
3089   if (config & E_NDS32_HAS_STRING_INST)
3090     r += snprintf (buf + r, size -r, ", STR");
3091
3092   if (config & E_NDS32_HAS_REDUCED_REGS)
3093     r += snprintf (buf + r, size -r, ", 16REG");
3094
3095   if (config & E_NDS32_HAS_VIDEO_INST)
3096     {
3097       if (version <= E_NDS32_ELF_VER_1_3)
3098         r += snprintf (buf + r, size -r, ", VIDEO");
3099       else
3100         r += snprintf (buf + r, size -r, ", SATURATION");
3101     }
3102
3103   if (config & E_NDS32_HAS_ENCRIPT_INST)
3104     r += snprintf (buf + r, size -r, ", ENCRP");
3105
3106   if (config & E_NDS32_HAS_L2C_INST)
3107     r += snprintf (buf + r, size -r, ", L2C");
3108 }
3109
3110 static char *
3111 get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine)
3112 {
3113   static char buf[1024];
3114
3115   buf[0] = '\0';
3116
3117   if (e_flags)
3118     {
3119       switch (e_machine)
3120         {
3121         default:
3122           break;
3123
3124         case EM_ARC_COMPACT2:
3125         case EM_ARC_COMPACT:
3126           decode_ARC_machine_flags (e_flags, e_machine, buf);
3127           break;
3128
3129         case EM_ARM:
3130           decode_ARM_machine_flags (e_flags, buf);
3131           break;
3132
3133         case EM_AVR:
3134           decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3135           break;
3136
3137         case EM_BLACKFIN:
3138           if (e_flags & EF_BFIN_PIC)
3139             strcat (buf, ", PIC");
3140
3141           if (e_flags & EF_BFIN_FDPIC)
3142             strcat (buf, ", FDPIC");
3143
3144           if (e_flags & EF_BFIN_CODE_IN_L1)
3145             strcat (buf, ", code in L1");
3146
3147           if (e_flags & EF_BFIN_DATA_IN_L1)
3148             strcat (buf, ", data in L1");
3149
3150           break;
3151
3152         case EM_CYGNUS_FRV:
3153           switch (e_flags & EF_FRV_CPU_MASK)
3154             {
3155             case EF_FRV_CPU_GENERIC:
3156               break;
3157
3158             default:
3159               strcat (buf, ", fr???");
3160               break;
3161
3162             case EF_FRV_CPU_FR300:
3163               strcat (buf, ", fr300");
3164               break;
3165
3166             case EF_FRV_CPU_FR400:
3167               strcat (buf, ", fr400");
3168               break;
3169             case EF_FRV_CPU_FR405:
3170               strcat (buf, ", fr405");
3171               break;
3172
3173             case EF_FRV_CPU_FR450:
3174               strcat (buf, ", fr450");
3175               break;
3176
3177             case EF_FRV_CPU_FR500:
3178               strcat (buf, ", fr500");
3179               break;
3180             case EF_FRV_CPU_FR550:
3181               strcat (buf, ", fr550");
3182               break;
3183
3184             case EF_FRV_CPU_SIMPLE:
3185               strcat (buf, ", simple");
3186               break;
3187             case EF_FRV_CPU_TOMCAT:
3188               strcat (buf, ", tomcat");
3189               break;
3190             }
3191           break;
3192
3193         case EM_68K:
3194           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3195             strcat (buf, ", m68000");
3196           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3197             strcat (buf, ", cpu32");
3198           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3199             strcat (buf, ", fido_a");
3200           else
3201             {
3202               char const * isa = _("unknown");
3203               char const * mac = _("unknown mac");
3204               char const * additional = NULL;
3205
3206               switch (e_flags & EF_M68K_CF_ISA_MASK)
3207                 {
3208                 case EF_M68K_CF_ISA_A_NODIV:
3209                   isa = "A";
3210                   additional = ", nodiv";
3211                   break;
3212                 case EF_M68K_CF_ISA_A:
3213                   isa = "A";
3214                   break;
3215                 case EF_M68K_CF_ISA_A_PLUS:
3216                   isa = "A+";
3217                   break;
3218                 case EF_M68K_CF_ISA_B_NOUSP:
3219                   isa = "B";
3220                   additional = ", nousp";
3221                   break;
3222                 case EF_M68K_CF_ISA_B:
3223                   isa = "B";
3224                   break;
3225                 case EF_M68K_CF_ISA_C:
3226                   isa = "C";
3227                   break;
3228                 case EF_M68K_CF_ISA_C_NODIV:
3229                   isa = "C";
3230                   additional = ", nodiv";
3231                   break;
3232                 }
3233               strcat (buf, ", cf, isa ");
3234               strcat (buf, isa);
3235               if (additional)
3236                 strcat (buf, additional);
3237               if (e_flags & EF_M68K_CF_FLOAT)
3238                 strcat (buf, ", float");
3239               switch (e_flags & EF_M68K_CF_MAC_MASK)
3240                 {
3241                 case 0:
3242                   mac = NULL;
3243                   break;
3244                 case EF_M68K_CF_MAC:
3245                   mac = "mac";
3246                   break;
3247                 case EF_M68K_CF_EMAC:
3248                   mac = "emac";
3249                   break;
3250                 case EF_M68K_CF_EMAC_B:
3251                   mac = "emac_b";
3252                   break;
3253                 }
3254               if (mac)
3255                 {
3256                   strcat (buf, ", ");
3257                   strcat (buf, mac);
3258                 }
3259             }
3260           break;
3261
3262         case EM_CYGNUS_MEP:
3263           switch (e_flags & EF_MEP_CPU_MASK)
3264             {
3265             case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3266             case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3267             case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3268             case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3269             case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3270             case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3271             default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3272             }
3273
3274           switch (e_flags & EF_MEP_COP_MASK)
3275             {
3276             case EF_MEP_COP_NONE: break;
3277             case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3278             case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3279             case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3280             case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3281             default: strcat (buf, _("<unknown MeP copro type>")); break;
3282             }
3283
3284           if (e_flags & EF_MEP_LIBRARY)
3285             strcat (buf, ", Built for Library");
3286
3287           if (e_flags & EF_MEP_INDEX_MASK)
3288             sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3289                      e_flags & EF_MEP_INDEX_MASK);
3290
3291           if (e_flags & ~ EF_MEP_ALL_FLAGS)
3292             sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3293                      e_flags & ~ EF_MEP_ALL_FLAGS);
3294           break;
3295
3296         case EM_PPC:
3297           if (e_flags & EF_PPC_EMB)
3298             strcat (buf, ", emb");
3299
3300           if (e_flags & EF_PPC_RELOCATABLE)
3301             strcat (buf, _(", relocatable"));
3302
3303           if (e_flags & EF_PPC_RELOCATABLE_LIB)
3304             strcat (buf, _(", relocatable-lib"));
3305           break;
3306
3307         case EM_PPC64:
3308           if (e_flags & EF_PPC64_ABI)
3309             {
3310               char abi[] = ", abiv0";
3311
3312               abi[6] += e_flags & EF_PPC64_ABI;
3313               strcat (buf, abi);
3314             }
3315           break;
3316
3317         case EM_V800:
3318           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3319             strcat (buf, ", RH850 ABI");
3320
3321           if (e_flags & EF_V800_850E3)
3322             strcat (buf, ", V3 architecture");
3323
3324           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3325             strcat (buf, ", FPU not used");
3326
3327           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3328             strcat (buf, ", regmode: COMMON");
3329
3330           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3331             strcat (buf, ", r4 not used");
3332
3333           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3334             strcat (buf, ", r30 not used");
3335
3336           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3337             strcat (buf, ", r5 not used");
3338
3339           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3340             strcat (buf, ", r2 not used");
3341
3342           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3343             {
3344               switch (e_flags & - e_flags)
3345                 {
3346                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3347                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3348                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3349                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3350                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3351                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3352                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3353                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3354                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3355                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3356                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3357                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3358                 default: break;
3359                 }
3360             }
3361           break;
3362
3363         case EM_V850:
3364         case EM_CYGNUS_V850:
3365           switch (e_flags & EF_V850_ARCH)
3366             {
3367             case E_V850E3V5_ARCH:
3368               strcat (buf, ", v850e3v5");
3369               break;
3370             case E_V850E2V3_ARCH:
3371               strcat (buf, ", v850e2v3");
3372               break;
3373             case E_V850E2_ARCH:
3374               strcat (buf, ", v850e2");
3375               break;
3376             case E_V850E1_ARCH:
3377               strcat (buf, ", v850e1");
3378               break;
3379             case E_V850E_ARCH:
3380               strcat (buf, ", v850e");
3381               break;
3382             case E_V850_ARCH:
3383               strcat (buf, ", v850");
3384               break;
3385             default:
3386               strcat (buf, _(", unknown v850 architecture variant"));
3387               break;
3388             }
3389           break;
3390
3391         case EM_M32R:
3392         case EM_CYGNUS_M32R:
3393           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3394             strcat (buf, ", m32r");
3395           break;
3396
3397         case EM_MIPS:
3398         case EM_MIPS_RS3_LE:
3399           if (e_flags & EF_MIPS_NOREORDER)
3400             strcat (buf, ", noreorder");
3401
3402           if (e_flags & EF_MIPS_PIC)
3403             strcat (buf, ", pic");
3404
3405           if (e_flags & EF_MIPS_CPIC)
3406             strcat (buf, ", cpic");
3407
3408           if (e_flags & EF_MIPS_UCODE)
3409             strcat (buf, ", ugen_reserved");
3410
3411           if (e_flags & EF_MIPS_ABI2)
3412             strcat (buf, ", abi2");
3413
3414           if (e_flags & EF_MIPS_OPTIONS_FIRST)
3415             strcat (buf, ", odk first");
3416
3417           if (e_flags & EF_MIPS_32BITMODE)
3418             strcat (buf, ", 32bitmode");
3419
3420           if (e_flags & EF_MIPS_NAN2008)
3421             strcat (buf, ", nan2008");
3422
3423           if (e_flags & EF_MIPS_FP64)
3424             strcat (buf, ", fp64");
3425
3426           switch ((e_flags & EF_MIPS_MACH))
3427             {
3428             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3429             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3430             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3431             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3432             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3433             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3434             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3435             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3436             case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break;
3437             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
3438             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3439             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3440             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3441             case E_MIPS_MACH_GS464: strcat (buf, ", gs464"); break;
3442             case E_MIPS_MACH_GS464E: strcat (buf, ", gs464e"); break;
3443             case E_MIPS_MACH_GS264E: strcat (buf, ", gs264e"); break;
3444             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3445             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3446             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3447             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
3448             case E_MIPS_MACH_IAMR2:  strcat (buf, ", interaptiv-mr2"); break;
3449             case 0:
3450             /* We simply ignore the field in this case to avoid confusion:
3451                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3452                extension.  */
3453               break;
3454             default: strcat (buf, _(", unknown CPU")); break;
3455             }
3456
3457           switch ((e_flags & EF_MIPS_ABI))
3458             {
3459             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3460             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3461             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3462             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3463             case 0:
3464             /* We simply ignore the field in this case to avoid confusion:
3465                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3466                This means it is likely to be an o32 file, but not for
3467                sure.  */
3468               break;
3469             default: strcat (buf, _(", unknown ABI")); break;
3470             }
3471
3472           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3473             strcat (buf, ", mdmx");
3474
3475           if (e_flags & EF_MIPS_ARCH_ASE_M16)
3476             strcat (buf, ", mips16");
3477
3478           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3479             strcat (buf, ", micromips");
3480
3481           switch ((e_flags & EF_MIPS_ARCH))
3482             {
3483             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3484             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3485             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3486             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3487             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3488             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3489             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3490             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3491             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3492             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3493             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3494             default: strcat (buf, _(", unknown ISA")); break;
3495             }
3496           break;
3497
3498         case EM_NDS32:
3499           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3500           break;
3501
3502         case EM_NFP:
3503           switch (EF_NFP_MACH (e_flags))
3504             {
3505             case E_NFP_MACH_3200:
3506               strcat (buf, ", NFP-32xx");
3507               break;
3508             case E_NFP_MACH_6000:
3509               strcat (buf, ", NFP-6xxx");
3510               break;
3511             }
3512           break;
3513
3514         case EM_RISCV:
3515           if (e_flags & EF_RISCV_RVC)
3516             strcat (buf, ", RVC");
3517
3518           if (e_flags & EF_RISCV_RVE)
3519             strcat (buf, ", RVE");
3520
3521           switch (e_flags & EF_RISCV_FLOAT_ABI)
3522             {
3523             case EF_RISCV_FLOAT_ABI_SOFT:
3524               strcat (buf, ", soft-float ABI");
3525               break;
3526
3527             case EF_RISCV_FLOAT_ABI_SINGLE:
3528               strcat (buf, ", single-float ABI");
3529               break;
3530
3531             case EF_RISCV_FLOAT_ABI_DOUBLE:
3532               strcat (buf, ", double-float ABI");
3533               break;
3534
3535             case EF_RISCV_FLOAT_ABI_QUAD:
3536               strcat (buf, ", quad-float ABI");
3537               break;
3538             }
3539           break;
3540
3541         case EM_SH:
3542           switch ((e_flags & EF_SH_MACH_MASK))
3543             {
3544             case EF_SH1: strcat (buf, ", sh1"); break;
3545             case EF_SH2: strcat (buf, ", sh2"); break;
3546             case EF_SH3: strcat (buf, ", sh3"); break;
3547             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3548             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3549             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3550             case EF_SH3E: strcat (buf, ", sh3e"); break;
3551             case EF_SH4: strcat (buf, ", sh4"); break;
3552             case EF_SH5: strcat (buf, ", sh5"); break;
3553             case EF_SH2E: strcat (buf, ", sh2e"); break;
3554             case EF_SH4A: strcat (buf, ", sh4a"); break;
3555             case EF_SH2A: strcat (buf, ", sh2a"); break;
3556             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3557             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3558             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3559             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3560             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3561             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3562             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3563             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3564             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3565             default: strcat (buf, _(", unknown ISA")); break;
3566             }
3567
3568           if (e_flags & EF_SH_PIC)
3569             strcat (buf, ", pic");
3570
3571           if (e_flags & EF_SH_FDPIC)
3572             strcat (buf, ", fdpic");
3573           break;
3574
3575         case EM_OR1K:
3576           if (e_flags & EF_OR1K_NODELAY)
3577             strcat (buf, ", no delay");
3578           break;
3579
3580         case EM_SPARCV9:
3581           if (e_flags & EF_SPARC_32PLUS)
3582             strcat (buf, ", v8+");
3583
3584           if (e_flags & EF_SPARC_SUN_US1)
3585             strcat (buf, ", ultrasparcI");
3586
3587           if (e_flags & EF_SPARC_SUN_US3)
3588             strcat (buf, ", ultrasparcIII");
3589
3590           if (e_flags & EF_SPARC_HAL_R1)
3591             strcat (buf, ", halr1");
3592
3593           if (e_flags & EF_SPARC_LEDATA)
3594             strcat (buf, ", ledata");
3595
3596           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3597             strcat (buf, ", tso");
3598
3599           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3600             strcat (buf, ", pso");
3601
3602           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3603             strcat (buf, ", rmo");
3604           break;
3605
3606         case EM_PARISC:
3607           switch (e_flags & EF_PARISC_ARCH)
3608             {
3609             case EFA_PARISC_1_0:
3610               strcpy (buf, ", PA-RISC 1.0");
3611               break;
3612             case EFA_PARISC_1_1:
3613               strcpy (buf, ", PA-RISC 1.1");
3614               break;
3615             case EFA_PARISC_2_0:
3616               strcpy (buf, ", PA-RISC 2.0");
3617               break;
3618             default:
3619               break;
3620             }
3621           if (e_flags & EF_PARISC_TRAPNIL)
3622             strcat (buf, ", trapnil");
3623           if (e_flags & EF_PARISC_EXT)
3624             strcat (buf, ", ext");
3625           if (e_flags & EF_PARISC_LSB)
3626             strcat (buf, ", lsb");
3627           if (e_flags & EF_PARISC_WIDE)
3628             strcat (buf, ", wide");
3629           if (e_flags & EF_PARISC_NO_KABP)
3630             strcat (buf, ", no kabp");
3631           if (e_flags & EF_PARISC_LAZYSWAP)
3632             strcat (buf, ", lazyswap");
3633           break;
3634
3635         case EM_PJ:
3636         case EM_PJ_OLD:
3637           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3638             strcat (buf, ", new calling convention");
3639
3640           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3641             strcat (buf, ", gnu calling convention");
3642           break;
3643
3644         case EM_IA_64:
3645           if ((e_flags & EF_IA_64_ABI64))
3646             strcat (buf, ", 64-bit");
3647           else
3648             strcat (buf, ", 32-bit");
3649           if ((e_flags & EF_IA_64_REDUCEDFP))
3650             strcat (buf, ", reduced fp model");
3651           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3652             strcat (buf, ", no function descriptors, constant gp");
3653           else if ((e_flags & EF_IA_64_CONS_GP))
3654             strcat (buf, ", constant gp");
3655           if ((e_flags & EF_IA_64_ABSOLUTE))
3656             strcat (buf, ", absolute");
3657           if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3658             {
3659               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3660                 strcat (buf, ", vms_linkages");
3661               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3662                 {
3663                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3664                   break;
3665                 case EF_IA_64_VMS_COMCOD_WARNING:
3666                   strcat (buf, ", warning");
3667                   break;
3668                 case EF_IA_64_VMS_COMCOD_ERROR:
3669                   strcat (buf, ", error");
3670                   break;
3671                 case EF_IA_64_VMS_COMCOD_ABORT:
3672                   strcat (buf, ", abort");
3673                   break;
3674                 default:
3675                   warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3676                         e_flags & EF_IA_64_VMS_COMCOD);
3677                   strcat (buf, ", <unknown>");
3678                 }
3679             }
3680           break;
3681
3682         case EM_VAX:
3683           if ((e_flags & EF_VAX_NONPIC))
3684             strcat (buf, ", non-PIC");
3685           if ((e_flags & EF_VAX_DFLOAT))
3686             strcat (buf, ", D-Float");
3687           if ((e_flags & EF_VAX_GFLOAT))
3688             strcat (buf, ", G-Float");
3689           break;
3690
3691         case EM_VISIUM:
3692           if (e_flags & EF_VISIUM_ARCH_MCM)
3693             strcat (buf, ", mcm");
3694           else if (e_flags & EF_VISIUM_ARCH_MCM24)
3695             strcat (buf, ", mcm24");
3696           if (e_flags & EF_VISIUM_ARCH_GR6)
3697             strcat (buf, ", gr6");
3698           break;
3699
3700         case EM_RL78:
3701           switch (e_flags & E_FLAG_RL78_CPU_MASK)
3702             {
3703             case E_FLAG_RL78_ANY_CPU: break;
3704             case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3705             case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3706             case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3707             }
3708           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3709             strcat (buf, ", 64-bit doubles");
3710           break;
3711
3712         case EM_RX:
3713           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3714             strcat (buf, ", 64-bit doubles");
3715           if (e_flags & E_FLAG_RX_DSP)
3716             strcat (buf, ", dsp");
3717           if (e_flags & E_FLAG_RX_PID)
3718             strcat (buf, ", pid");
3719           if (e_flags & E_FLAG_RX_ABI)
3720             strcat (buf, ", RX ABI");
3721           if (e_flags & E_FLAG_RX_SINSNS_SET)
3722             strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3723                     ? ", uses String instructions" : ", bans String instructions");
3724           if (e_flags & E_FLAG_RX_V2)
3725             strcat (buf, ", V2");
3726           if (e_flags & E_FLAG_RX_V3)
3727             strcat (buf, ", V3");
3728           break;
3729
3730         case EM_S390:
3731           if (e_flags & EF_S390_HIGH_GPRS)
3732             strcat (buf, ", highgprs");
3733           break;
3734
3735         case EM_TI_C6000:
3736           if ((e_flags & EF_C6000_REL))
3737             strcat (buf, ", relocatable module");
3738           break;
3739
3740         case EM_MSP430:
3741           strcat (buf, _(": architecture variant: "));
3742           switch (e_flags & EF_MSP430_MACH)
3743             {
3744             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3745             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3746             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3747             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3748             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3749             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3750             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3751             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3752             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3753             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3754             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3755             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3756             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3757             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3758             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3759             default:
3760               strcat (buf, _(": unknown")); break;
3761             }
3762
3763           if (e_flags & ~ EF_MSP430_MACH)
3764             strcat (buf, _(": unknown extra flag bits also present"));
3765         }
3766     }
3767
3768   return buf;
3769 }
3770
3771 static const char *
3772 get_osabi_name (Filedata * filedata, unsigned int osabi)
3773 {
3774   static char buff[32];
3775
3776   switch (osabi)
3777     {
3778     case ELFOSABI_NONE:         return "UNIX - System V";
3779     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3780     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3781     case ELFOSABI_GNU:          return "UNIX - GNU";
3782     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3783     case ELFOSABI_AIX:          return "UNIX - AIX";
3784     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3785     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3786     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3787     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3788     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3789     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3790     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3791     case ELFOSABI_AROS:         return "AROS";
3792     case ELFOSABI_FENIXOS:      return "FenixOS";
3793     case ELFOSABI_CLOUDABI:     return "Nuxi CloudABI";
3794     case ELFOSABI_OPENVOS:      return "Stratus Technologies OpenVOS";
3795     default:
3796       if (osabi >= 64)
3797         switch (filedata->file_header.e_machine)
3798           {
3799           case EM_ARM:
3800             switch (osabi)
3801               {
3802               case ELFOSABI_ARM:        return "ARM";
3803               case ELFOSABI_ARM_FDPIC:  return "ARM FDPIC";
3804               default:
3805                 break;
3806               }
3807             break;
3808
3809           case EM_MSP430:
3810           case EM_MSP430_OLD:
3811           case EM_VISIUM:
3812             switch (osabi)
3813               {
3814               case ELFOSABI_STANDALONE: return _("Standalone App");
3815               default:
3816                 break;
3817               }
3818             break;
3819
3820           case EM_TI_C6000:
3821             switch (osabi)
3822               {
3823               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3824               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3825               default:
3826                 break;
3827               }
3828             break;
3829
3830           default:
3831             break;
3832           }
3833       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3834       return buff;
3835     }
3836 }
3837
3838 static const char *
3839 get_aarch64_segment_type (unsigned long type)
3840 {
3841   switch (type)
3842     {
3843     case PT_AARCH64_ARCHEXT:  return "AARCH64_ARCHEXT";
3844     default:                  return NULL;
3845     }
3846 }
3847
3848 static const char *
3849 get_arm_segment_type (unsigned long type)
3850 {
3851   switch (type)
3852     {
3853     case PT_ARM_EXIDX: return "EXIDX";
3854     default:           return NULL;
3855     }
3856 }
3857
3858 static const char *
3859 get_s390_segment_type (unsigned long type)
3860 {
3861   switch (type)
3862     {
3863     case PT_S390_PGSTE: return "S390_PGSTE";
3864     default:            return NULL;
3865     }
3866 }
3867
3868 static const char *
3869 get_mips_segment_type (unsigned long type)
3870 {
3871   switch (type)
3872     {
3873     case PT_MIPS_REGINFO:   return "REGINFO";
3874     case PT_MIPS_RTPROC:    return "RTPROC";
3875     case PT_MIPS_OPTIONS:   return "OPTIONS";
3876     case PT_MIPS_ABIFLAGS:  return "ABIFLAGS";
3877     default:                return NULL;
3878     }
3879 }
3880
3881 static const char *
3882 get_parisc_segment_type (unsigned long type)
3883 {
3884   switch (type)
3885     {
3886     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3887     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3888     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3889     default:                    return NULL;
3890     }
3891 }
3892
3893 static const char *
3894 get_ia64_segment_type (unsigned long type)
3895 {
3896   switch (type)
3897     {
3898     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3899     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3900     default:                    return NULL;
3901     }
3902 }
3903
3904 static const char *
3905 get_tic6x_segment_type (unsigned long type)
3906 {
3907   switch (type)
3908     {
3909     case PT_C6000_PHATTR:  return "C6000_PHATTR";
3910     default:               return NULL;
3911     }
3912 }
3913
3914 static const char *
3915 get_hpux_segment_type (unsigned long type, unsigned e_machine)
3916 {
3917   if (e_machine == EM_PARISC)
3918     switch (type)
3919       {
3920       case PT_HP_TLS:           return "HP_TLS";
3921       case PT_HP_CORE_NONE:     return "HP_CORE_NONE";
3922       case PT_HP_CORE_VERSION:  return "HP_CORE_VERSION";
3923       case PT_HP_CORE_KERNEL:   return "HP_CORE_KERNEL";
3924       case PT_HP_CORE_COMM:     return "HP_CORE_COMM";
3925       case PT_HP_CORE_PROC:     return "HP_CORE_PROC";
3926       case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3927       case PT_HP_CORE_STACK:    return "HP_CORE_STACK";
3928       case PT_HP_CORE_SHM:      return "HP_CORE_SHM";
3929       case PT_HP_CORE_MMF:      return "HP_CORE_MMF";
3930       case PT_HP_PARALLEL:      return "HP_PARALLEL";
3931       case PT_HP_FASTBIND:      return "HP_FASTBIND";
3932       case PT_HP_OPT_ANNOT:     return "HP_OPT_ANNOT";
3933       case PT_HP_HSL_ANNOT:     return "HP_HSL_ANNOT";
3934       case PT_HP_STACK:         return "HP_STACK";
3935       case PT_HP_CORE_UTSNAME:  return "HP_CORE_UTSNAME";
3936       default:                  return NULL;
3937       }
3938
3939   if (e_machine == EM_IA_64)
3940     switch (type)
3941       {
3942       case PT_HP_TLS:            return "HP_TLS";
3943       case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3944       case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3945       case PT_IA_64_HP_STACK:    return "HP_STACK";
3946       default:                   return NULL;
3947       }
3948
3949   return NULL;
3950 }
3951
3952 static const char *
3953 get_solaris_segment_type (unsigned long type)
3954 {
3955   switch (type)
3956     {
3957     case 0x6464e550: return "PT_SUNW_UNWIND";
3958     case 0x6474e550: return "PT_SUNW_EH_FRAME";
3959     case 0x6ffffff7: return "PT_LOSUNW";
3960     case 0x6ffffffa: return "PT_SUNWBSS";
3961     case 0x6ffffffb: return "PT_SUNWSTACK";
3962     case 0x6ffffffc: return "PT_SUNWDTRACE";
3963     case 0x6ffffffd: return "PT_SUNWCAP";
3964     case 0x6fffffff: return "PT_HISUNW";
3965     default:         return NULL;
3966     }
3967 }
3968
3969 static const char *
3970 get_segment_type (Filedata * filedata, unsigned long p_type)
3971 {
3972   static char buff[32];
3973
3974   switch (p_type)
3975     {
3976     case PT_NULL:       return "NULL";
3977     case PT_LOAD:       return "LOAD";
3978     case PT_DYNAMIC:    return "DYNAMIC";
3979     case PT_INTERP:     return "INTERP";
3980     case PT_NOTE:       return "NOTE";
3981     case PT_SHLIB:      return "SHLIB";
3982     case PT_PHDR:       return "PHDR";
3983     case PT_TLS:        return "TLS";
3984     case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3985     case PT_GNU_STACK:  return "GNU_STACK";
3986     case PT_GNU_RELRO:  return "GNU_RELRO";
3987     case PT_GNU_PROPERTY: return "GNU_PROPERTY";
3988
3989     default:
3990       if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3991         {
3992           const char * result;
3993
3994           switch (filedata->file_header.e_machine)
3995             {
3996             case EM_AARCH64:
3997               result = get_aarch64_segment_type (p_type);
3998               break;
3999             case EM_ARM:
4000               result = get_arm_segment_type (p_type);
4001               break;
4002             case EM_MIPS:
4003             case EM_MIPS_RS3_LE:
4004               result = get_mips_segment_type (p_type);
4005               break;
4006             case EM_PARISC:
4007               result = get_parisc_segment_type (p_type);
4008               break;
4009             case EM_IA_64:
4010               result = get_ia64_segment_type (p_type);
4011               break;
4012             case EM_TI_C6000:
4013               result = get_tic6x_segment_type (p_type);
4014               break;
4015             case EM_S390:
4016             case EM_S390_OLD:
4017               result = get_s390_segment_type (p_type);
4018               break;
4019             default:
4020               result = NULL;
4021               break;
4022             }
4023
4024           if (result != NULL)
4025             return result;
4026
4027           sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
4028         }
4029       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
4030         {
4031           const char * result = NULL;
4032
4033           switch (filedata->file_header.e_ident[EI_OSABI])
4034             {
4035             case ELFOSABI_GNU:
4036             case ELFOSABI_FREEBSD:
4037               if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
4038                 {
4039                   sprintf (buff, "GNU_MBIND+%#lx", p_type - PT_GNU_MBIND_LO);
4040                   result = buff;
4041                 }
4042               break;
4043             case ELFOSABI_HPUX:
4044               result = get_hpux_segment_type (p_type,
4045                                               filedata->file_header.e_machine);
4046               break;
4047             case ELFOSABI_SOLARIS:
4048               result = get_solaris_segment_type (p_type);
4049               break;
4050             default:
4051               break;
4052             }
4053           if (result != NULL)
4054             return result;
4055
4056           sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
4057         }
4058       else
4059         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
4060
4061       return buff;
4062     }
4063 }
4064
4065 static const char *
4066 get_arc_section_type_name (unsigned int sh_type)
4067 {
4068   switch (sh_type)
4069     {
4070     case SHT_ARC_ATTRIBUTES:      return "ARC_ATTRIBUTES";
4071     default:
4072       break;
4073     }
4074   return NULL;
4075 }
4076
4077 static const char *
4078 get_mips_section_type_name (unsigned int sh_type)
4079 {
4080   switch (sh_type)
4081     {
4082     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
4083     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
4084     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
4085     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
4086     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
4087     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
4088     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
4089     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
4090     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
4091     case SHT_MIPS_RELD:          return "MIPS_RELD";
4092     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
4093     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
4094     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
4095     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
4096     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
4097     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
4098     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
4099     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
4100     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
4101     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
4102     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
4103     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
4104     case SHT_MIPS_LINE:          return "MIPS_LINE";
4105     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
4106     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
4107     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
4108     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
4109     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
4110     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
4111     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
4112     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
4113     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
4114     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
4115     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
4116     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
4117     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
4118     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
4119     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
4120     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
4121     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
4122     case SHT_MIPS_XHASH:         return "MIPS_XHASH";
4123     default:
4124       break;
4125     }
4126   return NULL;
4127 }
4128
4129 static const char *
4130 get_parisc_section_type_name (unsigned int sh_type)
4131 {
4132   switch (sh_type)
4133     {
4134     case SHT_PARISC_EXT:        return "PARISC_EXT";
4135     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
4136     case SHT_PARISC_DOC:        return "PARISC_DOC";
4137     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
4138     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
4139     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
4140     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
4141     default:                    return NULL;
4142     }
4143 }
4144
4145 static const char *
4146 get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
4147 {
4148   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
4149   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4150     return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
4151
4152   switch (sh_type)
4153     {
4154     case SHT_IA_64_EXT:                return "IA_64_EXT";
4155     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
4156     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
4157     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
4158     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4159     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
4160     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
4161     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
4162     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
4163     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
4164     default:
4165       break;
4166     }
4167   return NULL;
4168 }
4169
4170 static const char *
4171 get_x86_64_section_type_name (unsigned int sh_type)
4172 {
4173   switch (sh_type)
4174     {
4175     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
4176     default:                    return NULL;
4177     }
4178 }
4179
4180 static const char *
4181 get_aarch64_section_type_name (unsigned int sh_type)
4182 {
4183   switch (sh_type)
4184     {
4185     case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4186     default:                     return NULL;
4187     }
4188 }
4189
4190 static const char *
4191 get_arm_section_type_name (unsigned int sh_type)
4192 {
4193   switch (sh_type)
4194     {
4195     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
4196     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
4197     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
4198     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
4199     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
4200     default:                      return NULL;
4201     }
4202 }
4203
4204 static const char *
4205 get_tic6x_section_type_name (unsigned int sh_type)
4206 {
4207   switch (sh_type)
4208     {
4209     case SHT_C6000_UNWIND:      return "C6000_UNWIND";
4210     case SHT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
4211     case SHT_C6000_ATTRIBUTES:  return "C6000_ATTRIBUTES";
4212     case SHT_TI_ICODE:          return "TI_ICODE";
4213     case SHT_TI_XREF:           return "TI_XREF";
4214     case SHT_TI_HANDLER:        return "TI_HANDLER";
4215     case SHT_TI_INITINFO:       return "TI_INITINFO";
4216     case SHT_TI_PHATTRS:        return "TI_PHATTRS";
4217     default:                    return NULL;
4218     }
4219 }
4220
4221 static const char *
4222 get_msp430x_section_type_name (unsigned int sh_type)
4223 {
4224   switch (sh_type)
4225     {
4226     case SHT_MSP430_SEC_FLAGS:    return "MSP430_SEC_FLAGS";
4227     case SHT_MSP430_SYM_ALIASES:  return "MSP430_SYM_ALIASES";
4228     case SHT_MSP430_ATTRIBUTES:   return "MSP430_ATTRIBUTES";
4229     default:                      return NULL;
4230     }
4231 }
4232
4233 static const char *
4234 get_nfp_section_type_name (unsigned int sh_type)
4235 {
4236   switch (sh_type)
4237     {
4238     case SHT_NFP_MECONFIG:      return "NFP_MECONFIG";
4239     case SHT_NFP_INITREG:       return "NFP_INITREG";
4240     case SHT_NFP_UDEBUG:        return "NFP_UDEBUG";
4241     default:                    return NULL;
4242     }
4243 }
4244
4245 static const char *
4246 get_v850_section_type_name (unsigned int sh_type)
4247 {
4248   switch (sh_type)
4249     {
4250     case SHT_V850_SCOMMON:  return "V850 Small Common";
4251     case SHT_V850_TCOMMON:  return "V850 Tiny Common";
4252     case SHT_V850_ZCOMMON:  return "V850 Zero Common";
4253     case SHT_RENESAS_IOP:   return "RENESAS IOP";
4254     case SHT_RENESAS_INFO:  return "RENESAS INFO";
4255     default:                return NULL;
4256     }
4257 }
4258
4259 static const char *
4260 get_riscv_section_type_name (unsigned int sh_type)
4261 {
4262   switch (sh_type)
4263     {
4264     case SHT_RISCV_ATTRIBUTES:  return "RISCV_ATTRIBUTES";
4265     default: return NULL;
4266     }
4267 }
4268
4269 static const char *
4270 get_section_type_name (Filedata * filedata, unsigned int sh_type)
4271 {
4272   static char buff[32];
4273   const char * result;
4274
4275   switch (sh_type)
4276     {
4277     case SHT_NULL:              return "NULL";
4278     case SHT_PROGBITS:          return "PROGBITS";
4279     case SHT_SYMTAB:            return "SYMTAB";
4280     case SHT_STRTAB:            return "STRTAB";
4281     case SHT_RELA:              return "RELA";
4282     case SHT_HASH:              return "HASH";
4283     case SHT_DYNAMIC:           return "DYNAMIC";
4284     case SHT_NOTE:              return "NOTE";
4285     case SHT_NOBITS:            return "NOBITS";
4286     case SHT_REL:               return "REL";
4287     case SHT_SHLIB:             return "SHLIB";
4288     case SHT_DYNSYM:            return "DYNSYM";
4289     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
4290     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
4291     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
4292     case SHT_GNU_HASH:          return "GNU_HASH";
4293     case SHT_GROUP:             return "GROUP";
4294     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICES";
4295     case SHT_GNU_verdef:        return "VERDEF";
4296     case SHT_GNU_verneed:       return "VERNEED";
4297     case SHT_GNU_versym:        return "VERSYM";
4298     case 0x6ffffff0:            return "VERSYM";
4299     case 0x6ffffffc:            return "VERDEF";
4300     case 0x7ffffffd:            return "AUXILIARY";
4301     case 0x7fffffff:            return "FILTER";
4302     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
4303
4304     default:
4305       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4306         {
4307           switch (filedata->file_header.e_machine)
4308             {
4309             case EM_ARC:
4310             case EM_ARC_COMPACT:
4311             case EM_ARC_COMPACT2:
4312               result = get_arc_section_type_name (sh_type);
4313               break;
4314             case EM_MIPS:
4315             case EM_MIPS_RS3_LE:
4316               result = get_mips_section_type_name (sh_type);
4317               break;
4318             case EM_PARISC:
4319               result = get_parisc_section_type_name (sh_type);
4320               break;
4321             case EM_IA_64:
4322               result = get_ia64_section_type_name (filedata, sh_type);
4323               break;
4324             case EM_X86_64:
4325             case EM_L1OM:
4326             case EM_K1OM:
4327               result = get_x86_64_section_type_name (sh_type);
4328               break;
4329             case EM_AARCH64:
4330               result = get_aarch64_section_type_name (sh_type);
4331               break;
4332             case EM_ARM:
4333               result = get_arm_section_type_name (sh_type);
4334               break;
4335             case EM_TI_C6000:
4336               result = get_tic6x_section_type_name (sh_type);
4337               break;
4338             case EM_MSP430:
4339               result = get_msp430x_section_type_name (sh_type);
4340               break;
4341             case EM_NFP:
4342               result = get_nfp_section_type_name (sh_type);
4343               break;
4344             case EM_V800:
4345             case EM_V850:
4346             case EM_CYGNUS_V850:
4347               result = get_v850_section_type_name (sh_type);
4348               break;
4349             case EM_RISCV:
4350               result = get_riscv_section_type_name (sh_type);
4351               break;
4352             default:
4353               result = NULL;
4354               break;
4355             }
4356
4357           if (result != NULL)
4358             return result;
4359
4360           sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4361         }
4362       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4363         {
4364           switch (filedata->file_header.e_machine)
4365             {
4366             case EM_IA_64:
4367               result = get_ia64_section_type_name (filedata, sh_type);
4368               break;
4369             default:
4370               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4371                 result = get_solaris_section_type (sh_type);
4372               else
4373                 {
4374                   switch (sh_type)
4375                     {
4376                     case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4377                     case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4378                     case SHT_GNU_HASH: result = "GNU_HASH"; break;
4379                     case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4380                     default:
4381                       result = NULL;
4382                       break;
4383                     }
4384                 }
4385               break;
4386             }
4387
4388           if (result != NULL)
4389             return result;
4390
4391           sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4392         }
4393       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4394         {
4395           switch (filedata->file_header.e_machine)
4396             {
4397             case EM_V800:
4398             case EM_V850:
4399             case EM_CYGNUS_V850:
4400               result = get_v850_section_type_name (sh_type);
4401               break;
4402             default:
4403               result = NULL;
4404               break;
4405             }
4406
4407           if (result != NULL)
4408             return result;
4409
4410           sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4411         }
4412       else
4413         /* This message is probably going to be displayed in a 15
4414            character wide field, so put the hex value first.  */
4415         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4416
4417       return buff;
4418     }
4419 }
4420
4421 #define OPTION_DEBUG_DUMP       512
4422 #define OPTION_DYN_SYMS         513
4423 #define OPTION_DWARF_DEPTH      514
4424 #define OPTION_DWARF_START      515
4425 #define OPTION_DWARF_CHECK      516
4426 #define OPTION_CTF_DUMP         517
4427 #define OPTION_CTF_PARENT       518
4428 #define OPTION_CTF_SYMBOLS      519
4429 #define OPTION_CTF_STRINGS      520
4430
4431 static struct option options[] =
4432 {
4433   {"all",              no_argument, 0, 'a'},
4434   {"file-header",      no_argument, 0, 'h'},
4435   {"program-headers",  no_argument, 0, 'l'},
4436   {"headers",          no_argument, 0, 'e'},
4437   {"histogram",        no_argument, 0, 'I'},
4438   {"segments",         no_argument, 0, 'l'},
4439   {"sections",         no_argument, 0, 'S'},
4440   {"section-headers",  no_argument, 0, 'S'},
4441   {"section-groups",   no_argument, 0, 'g'},
4442   {"section-details",  no_argument, 0, 't'},
4443   {"full-section-name",no_argument, 0, 'N'},
4444   {"symbols",          no_argument, 0, 's'},
4445   {"syms",             no_argument, 0, 's'},
4446   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
4447   {"relocs",           no_argument, 0, 'r'},
4448   {"notes",            no_argument, 0, 'n'},
4449   {"dynamic",          no_argument, 0, 'd'},
4450   {"arch-specific",    no_argument, 0, 'A'},
4451   {"version-info",     no_argument, 0, 'V'},
4452   {"use-dynamic",      no_argument, 0, 'D'},
4453   {"unwind",           no_argument, 0, 'u'},
4454   {"archive-index",    no_argument, 0, 'c'},
4455   {"hex-dump",         required_argument, 0, 'x'},
4456   {"relocated-dump",   required_argument, 0, 'R'},
4457   {"string-dump",      required_argument, 0, 'p'},
4458   {"decompress",       no_argument, 0, 'z'},
4459 #ifdef SUPPORT_DISASSEMBLY
4460   {"instruction-dump", required_argument, 0, 'i'},
4461 #endif
4462   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
4463
4464   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
4465   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
4466   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
4467
4468   {"ctf",              required_argument, 0, OPTION_CTF_DUMP},
4469
4470   {"ctf-symbols",      required_argument, 0, OPTION_CTF_SYMBOLS},
4471   {"ctf-strings",      required_argument, 0, OPTION_CTF_STRINGS},
4472   {"ctf-parent",       required_argument, 0, OPTION_CTF_PARENT},
4473
4474   {"version",          no_argument, 0, 'v'},
4475   {"wide",             no_argument, 0, 'W'},
4476   {"help",             no_argument, 0, 'H'},
4477   {0,                  no_argument, 0, 0}
4478 };
4479
4480 static void
4481 usage (FILE * stream)
4482 {
4483   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4484   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4485   fprintf (stream, _(" Options are:\n\
4486   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4487   -h --file-header       Display the ELF file header\n\
4488   -l --program-headers   Display the program headers\n\
4489      --segments          An alias for --program-headers\n\
4490   -S --section-headers   Display the sections' header\n\
4491      --sections          An alias for --section-headers\n\
4492   -g --section-groups    Display the section groups\n\
4493   -t --section-details   Display the section details\n\
4494   -e --headers           Equivalent to: -h -l -S\n\
4495   -s --syms              Display the symbol table\n\
4496      --symbols           An alias for --syms\n\
4497   --dyn-syms             Display the dynamic symbol table\n\
4498   -n --notes             Display the core notes (if present)\n\
4499   -r --relocs            Display the relocations (if present)\n\
4500   -u --unwind            Display the unwind info (if present)\n\
4501   -d --dynamic           Display the dynamic section (if present)\n\
4502   -V --version-info      Display the version sections (if present)\n\
4503   -A --arch-specific     Display architecture specific information (if any)\n\
4504   -c --archive-index     Display the symbol/file index in an archive\n\
4505   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
4506   -x --hex-dump=<number|name>\n\
4507                          Dump the contents of section <number|name> as bytes\n\
4508   -p --string-dump=<number|name>\n\
4509                          Dump the contents of section <number|name> as strings\n\
4510   -R --relocated-dump=<number|name>\n\
4511                          Dump the contents of section <number|name> as relocated bytes\n\
4512   -z --decompress        Decompress section before dumping it\n\
4513   -w[lLiaprmfFsoRtUuTgAckK] or\n\
4514   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4515                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4516                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4517                =addr,=cu_index,=links,=follow-links]\n\
4518                          Display the contents of DWARF debug sections\n"));
4519   fprintf (stream, _("\
4520   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
4521   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
4522                          or deeper\n"));
4523   fprintf (stream, _("\
4524   --ctf=<number|name>    Display CTF info from section <number|name>\n\
4525   --ctf-parent=<number|name>\n\
4526                          Use section <number|name> as the CTF parent\n\n\
4527   --ctf-symbols=<number|name>\n\
4528                          Use section <number|name> as the CTF external symtab\n\n\
4529   --ctf-strings=<number|name>\n\
4530                          Use section <number|name> as the CTF external strtab\n\n"));
4531
4532 #ifdef SUPPORT_DISASSEMBLY
4533   fprintf (stream, _("\
4534   -i --instruction-dump=<number|name>\n\
4535                          Disassemble the contents of section <number|name>\n"));
4536 #endif
4537   fprintf (stream, _("\
4538   -I --histogram         Display histogram of bucket list lengths\n\
4539   -W --wide              Allow output width to exceed 80 characters\n\
4540   @<file>                Read options from <file>\n\
4541   -H --help              Display this information\n\
4542   -v --version           Display the version number of readelf\n"));
4543
4544   if (REPORT_BUGS_TO[0] && stream == stdout)
4545     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4546
4547   exit (stream == stdout ? 0 : 1);
4548 }
4549
4550 /* Record the fact that the user wants the contents of section number
4551    SECTION to be displayed using the method(s) encoded as flags bits
4552    in TYPE.  Note, TYPE can be zero if we are creating the array for
4553    the first time.  */
4554
4555 static void
4556 request_dump_bynumber (Filedata * filedata, unsigned int section, dump_type type)
4557 {
4558   if (section >= filedata->num_dump_sects)
4559     {
4560       dump_type * new_dump_sects;
4561
4562       new_dump_sects = (dump_type *) calloc (section + 1,
4563                                              sizeof (* new_dump_sects));
4564
4565       if (new_dump_sects == NULL)
4566         error (_("Out of memory allocating dump request table.\n"));
4567       else
4568         {
4569           if (filedata->dump_sects)
4570             {
4571               /* Copy current flag settings.  */
4572               memcpy (new_dump_sects, filedata->dump_sects,
4573                       filedata->num_dump_sects * sizeof (* new_dump_sects));
4574
4575               free (filedata->dump_sects);
4576             }
4577
4578           filedata->dump_sects = new_dump_sects;
4579           filedata->num_dump_sects = section + 1;
4580         }
4581     }
4582
4583   if (filedata->dump_sects)
4584     filedata->dump_sects[section] |= type;
4585 }
4586
4587 /* Request a dump by section name.  */
4588
4589 static void
4590 request_dump_byname (const char * section, dump_type type)
4591 {
4592   struct dump_list_entry * new_request;
4593
4594   new_request = (struct dump_list_entry *)
4595       malloc (sizeof (struct dump_list_entry));
4596   if (!new_request)
4597     error (_("Out of memory allocating dump request table.\n"));
4598
4599   new_request->name = strdup (section);
4600   if (!new_request->name)
4601     error (_("Out of memory allocating dump request table.\n"));
4602
4603   new_request->type = type;
4604
4605   new_request->next = dump_sects_byname;
4606   dump_sects_byname = new_request;
4607 }
4608
4609 static inline void
4610 request_dump (Filedata * filedata, dump_type type)
4611 {
4612   int section;
4613   char * cp;
4614
4615   do_dump++;
4616   section = strtoul (optarg, & cp, 0);
4617
4618   if (! *cp && section >= 0)
4619     request_dump_bynumber (filedata, section, type);
4620   else
4621     request_dump_byname (optarg, type);
4622 }
4623
4624 static void
4625 parse_args (Filedata * filedata, int argc, char ** argv)
4626 {
4627   int c;
4628
4629   if (argc < 2)
4630     usage (stderr);
4631
4632   while ((c = getopt_long
4633           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4634     {
4635       switch (c)
4636         {
4637         case 0:
4638           /* Long options.  */
4639           break;
4640         case 'H':
4641           usage (stdout);
4642           break;
4643
4644         case 'a':
4645           do_syms = TRUE;
4646           do_reloc = TRUE;
4647           do_unwind = TRUE;
4648           do_dynamic = TRUE;
4649           do_header = TRUE;
4650           do_sections = TRUE;
4651           do_section_groups = TRUE;
4652           do_segments = TRUE;
4653           do_version = TRUE;
4654           do_histogram = TRUE;
4655           do_arch = TRUE;
4656           do_notes = TRUE;
4657           break;
4658         case 'g':
4659           do_section_groups = TRUE;
4660           break;
4661         case 't':
4662         case 'N':
4663           do_sections = TRUE;
4664           do_section_details = TRUE;
4665           break;
4666         case 'e':
4667           do_header = TRUE;
4668           do_sections = TRUE;
4669           do_segments = TRUE;
4670           break;
4671         case 'A':
4672           do_arch = TRUE;
4673           break;
4674         case 'D':
4675           do_using_dynamic = TRUE;
4676           break;
4677         case 'r':
4678           do_reloc = TRUE;
4679           break;
4680         case 'u':
4681           do_unwind = TRUE;
4682           break;
4683         case 'h':
4684           do_header = TRUE;
4685           break;
4686         case 'l':
4687           do_segments = TRUE;
4688           break;
4689         case 's':
4690           do_syms = TRUE;
4691           break;
4692         case 'S':
4693           do_sections = TRUE;
4694           break;
4695         case 'd':
4696           do_dynamic = TRUE;
4697           break;
4698         case 'I':
4699           do_histogram = TRUE;
4700           break;
4701         case 'n':
4702           do_notes = TRUE;
4703           break;
4704         case 'c':
4705           do_archive_index = TRUE;
4706           break;
4707         case 'x':
4708           request_dump (filedata, HEX_DUMP);
4709           break;
4710         case 'p':
4711           request_dump (filedata, STRING_DUMP);
4712           break;
4713         case 'R':
4714           request_dump (filedata, RELOC_DUMP);
4715           break;
4716         case 'z':
4717           decompress_dumps = TRUE;
4718           break;
4719         case 'w':
4720           do_dump = TRUE;
4721           if (optarg == 0)
4722             {
4723               do_debugging = TRUE;
4724               dwarf_select_sections_all ();
4725             }
4726           else
4727             {
4728               do_debugging = FALSE;
4729               dwarf_select_sections_by_letters (optarg);
4730             }
4731           break;
4732         case OPTION_DEBUG_DUMP:
4733           do_dump = TRUE;
4734           if (optarg == 0)
4735             do_debugging = TRUE;
4736           else
4737             {
4738               do_debugging = FALSE;
4739               dwarf_select_sections_by_names (optarg);
4740             }
4741           break;
4742         case OPTION_DWARF_DEPTH:
4743           {
4744             char *cp;
4745
4746             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4747           }
4748           break;
4749         case OPTION_DWARF_START:
4750           {
4751             char *cp;
4752
4753             dwarf_start_die = strtoul (optarg, & cp, 0);
4754           }
4755           break;
4756         case OPTION_DWARF_CHECK:
4757           dwarf_check = TRUE;
4758           break;
4759         case OPTION_CTF_DUMP:
4760           do_ctf = TRUE;
4761           request_dump (filedata, CTF_DUMP);
4762           break;
4763         case OPTION_CTF_SYMBOLS:
4764           dump_ctf_symtab_name = strdup (optarg);
4765           break;
4766         case OPTION_CTF_STRINGS:
4767           dump_ctf_strtab_name = strdup (optarg);
4768           break;
4769         case OPTION_CTF_PARENT:
4770           dump_ctf_parent_name = strdup (optarg);
4771           break;
4772         case OPTION_DYN_SYMS:
4773           do_dyn_syms = TRUE;
4774           break;
4775 #ifdef SUPPORT_DISASSEMBLY
4776         case 'i':
4777           request_dump (filedata, DISASS_DUMP);
4778           break;
4779 #endif
4780         case 'v':
4781           print_version (program_name);
4782           break;
4783         case 'V':
4784           do_version = TRUE;
4785           break;
4786         case 'W':
4787           do_wide = TRUE;
4788           break;
4789         default:
4790           /* xgettext:c-format */
4791           error (_("Invalid option '-%c'\n"), c);
4792           /* Fall through.  */
4793         case '?':
4794           usage (stderr);
4795         }
4796     }
4797
4798   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4799       && !do_segments && !do_header && !do_dump && !do_version
4800       && !do_histogram && !do_debugging && !do_arch && !do_notes
4801       && !do_section_groups && !do_archive_index
4802       && !do_dyn_syms)
4803     usage (stderr);
4804 }
4805
4806 static const char *
4807 get_elf_class (unsigned int elf_class)
4808 {
4809   static char buff[32];
4810
4811   switch (elf_class)
4812     {
4813     case ELFCLASSNONE: return _("none");
4814     case ELFCLASS32:   return "ELF32";
4815     case ELFCLASS64:   return "ELF64";
4816     default:
4817       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4818       return buff;
4819     }
4820 }
4821
4822 static const char *
4823 get_data_encoding (unsigned int encoding)
4824 {
4825   static char buff[32];
4826
4827   switch (encoding)
4828     {
4829     case ELFDATANONE: return _("none");
4830     case ELFDATA2LSB: return _("2's complement, little endian");
4831     case ELFDATA2MSB: return _("2's complement, big endian");
4832     default:
4833       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4834       return buff;
4835     }
4836 }
4837
4838 /* Decode the data held in 'filedata->file_header'.  */
4839
4840 static bfd_boolean
4841 process_file_header (Filedata * filedata)
4842 {
4843   Elf_Internal_Ehdr * header = & filedata->file_header;
4844
4845   if (   header->e_ident[EI_MAG0] != ELFMAG0
4846       || header->e_ident[EI_MAG1] != ELFMAG1
4847       || header->e_ident[EI_MAG2] != ELFMAG2
4848       || header->e_ident[EI_MAG3] != ELFMAG3)
4849     {
4850       error
4851         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4852       return FALSE;
4853     }
4854
4855   init_dwarf_regnames (header->e_machine);
4856
4857   if (do_header)
4858     {
4859       unsigned i;
4860
4861       printf (_("ELF Header:\n"));
4862       printf (_("  Magic:   "));
4863       for (i = 0; i < EI_NIDENT; i++)
4864         printf ("%2.2x ", header->e_ident[i]);
4865       printf ("\n");
4866       printf (_("  Class:                             %s\n"),
4867               get_elf_class (header->e_ident[EI_CLASS]));
4868       printf (_("  Data:                              %s\n"),
4869               get_data_encoding (header->e_ident[EI_DATA]));
4870       printf (_("  Version:                           %d%s\n"),
4871               header->e_ident[EI_VERSION],
4872               (header->e_ident[EI_VERSION] == EV_CURRENT
4873                ? _(" (current)")
4874                : (header->e_ident[EI_VERSION] != EV_NONE
4875                   ? _(" <unknown>")
4876                   : "")));
4877       printf (_("  OS/ABI:                            %s\n"),
4878               get_osabi_name (filedata, header->e_ident[EI_OSABI]));
4879       printf (_("  ABI Version:                       %d\n"),
4880               header->e_ident[EI_ABIVERSION]);
4881       printf (_("  Type:                              %s\n"),
4882               get_file_type (header->e_type));
4883       printf (_("  Machine:                           %s\n"),
4884               get_machine_name (header->e_machine));
4885       printf (_("  Version:                           0x%lx\n"),
4886               header->e_version);
4887
4888       printf (_("  Entry point address:               "));
4889       print_vma (header->e_entry, PREFIX_HEX);
4890       printf (_("\n  Start of program headers:          "));
4891       print_vma (header->e_phoff, DEC);
4892       printf (_(" (bytes into file)\n  Start of section headers:          "));
4893       print_vma (header->e_shoff, DEC);
4894       printf (_(" (bytes into file)\n"));
4895
4896       printf (_("  Flags:                             0x%lx%s\n"),
4897               header->e_flags,
4898               get_machine_flags (filedata, header->e_flags, header->e_machine));
4899       printf (_("  Size of this header:               %u (bytes)\n"),
4900               header->e_ehsize);
4901       printf (_("  Size of program headers:           %u (bytes)\n"),
4902               header->e_phentsize);
4903       printf (_("  Number of program headers:         %u"),
4904               header->e_phnum);
4905       if (filedata->section_headers != NULL
4906           && header->e_phnum == PN_XNUM
4907           && filedata->section_headers[0].sh_info != 0)
4908         {
4909           header->e_phnum = filedata->section_headers[0].sh_info;
4910           printf (" (%u)", header->e_phnum);
4911         }
4912       putc ('\n', stdout);
4913       printf (_("  Size of section headers:           %u (bytes)\n"),
4914               header->e_shentsize);
4915       printf (_("  Number of section headers:         %u"),
4916               header->e_shnum);
4917       if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
4918         {
4919           header->e_shnum = filedata->section_headers[0].sh_size;
4920           printf (" (%u)", header->e_shnum);
4921         }
4922       putc ('\n', stdout);
4923       printf (_("  Section header string table index: %u"),
4924               header->e_shstrndx);
4925       if (filedata->section_headers != NULL
4926           && header->e_shstrndx == (SHN_XINDEX & 0xffff))
4927         {
4928           header->e_shstrndx = filedata->section_headers[0].sh_link;
4929           printf (" (%u)", header->e_shstrndx);
4930         }
4931       if (header->e_shstrndx != SHN_UNDEF
4932           && header->e_shstrndx >= header->e_shnum)
4933         {
4934           header->e_shstrndx = SHN_UNDEF;
4935           printf (_(" <corrupt: out of range>"));
4936         }
4937       putc ('\n', stdout);
4938     }
4939
4940   if (filedata->section_headers != NULL)
4941     {
4942       if (header->e_phnum == PN_XNUM
4943           && filedata->section_headers[0].sh_info != 0)
4944         header->e_phnum = filedata->section_headers[0].sh_info;
4945       if (header->e_shnum == SHN_UNDEF)
4946         header->e_shnum = filedata->section_headers[0].sh_size;
4947       if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
4948         header->e_shstrndx = filedata->section_headers[0].sh_link;
4949       if (header->e_shstrndx >= header->e_shnum)
4950         header->e_shstrndx = SHN_UNDEF;
4951       free (filedata->section_headers);
4952       filedata->section_headers = NULL;
4953     }
4954
4955   return TRUE;
4956 }
4957
4958 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4959    Returns TRUE upon success, FALSE otherwise.  Loads 32-bit headers.  */
4960
4961 static bfd_boolean
4962 get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4963 {
4964   Elf32_External_Phdr * phdrs;
4965   Elf32_External_Phdr * external;
4966   Elf_Internal_Phdr *   internal;
4967   unsigned int i;
4968   unsigned int size = filedata->file_header.e_phentsize;
4969   unsigned int num  = filedata->file_header.e_phnum;
4970
4971   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4972   if (size == 0 || num == 0)
4973     return FALSE;
4974   if (size < sizeof * phdrs)
4975     {
4976       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4977       return FALSE;
4978     }
4979   if (size > sizeof * phdrs)
4980     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4981
4982   phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4983                                             size, num, _("program headers"));
4984   if (phdrs == NULL)
4985     return FALSE;
4986
4987   for (i = 0, internal = pheaders, external = phdrs;
4988        i < filedata->file_header.e_phnum;
4989        i++, internal++, external++)
4990     {
4991       internal->p_type   = BYTE_GET (external->p_type);
4992       internal->p_offset = BYTE_GET (external->p_offset);
4993       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4994       internal->p_paddr  = BYTE_GET (external->p_paddr);
4995       internal->p_filesz = BYTE_GET (external->p_filesz);
4996       internal->p_memsz  = BYTE_GET (external->p_memsz);
4997       internal->p_flags  = BYTE_GET (external->p_flags);
4998       internal->p_align  = BYTE_GET (external->p_align);
4999     }
5000
5001   free (phdrs);
5002   return TRUE;
5003 }
5004
5005 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5006    Returns TRUE upon success, FALSE otherwise.  Loads 64-bit headers.  */
5007
5008 static bfd_boolean
5009 get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
5010 {
5011   Elf64_External_Phdr * phdrs;
5012   Elf64_External_Phdr * external;
5013   Elf_Internal_Phdr *   internal;
5014   unsigned int i;
5015   unsigned int size = filedata->file_header.e_phentsize;
5016   unsigned int num  = filedata->file_header.e_phnum;
5017
5018   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5019   if (size == 0 || num == 0)
5020     return FALSE;
5021   if (size < sizeof * phdrs)
5022     {
5023       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5024       return FALSE;
5025     }
5026   if (size > sizeof * phdrs)
5027     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5028
5029   phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
5030                                             size, num, _("program headers"));
5031   if (!phdrs)
5032     return FALSE;
5033
5034   for (i = 0, internal = pheaders, external = phdrs;
5035        i < filedata->file_header.e_phnum;
5036        i++, internal++, external++)
5037     {
5038       internal->p_type   = BYTE_GET (external->p_type);
5039       internal->p_flags  = BYTE_GET (external->p_flags);
5040       internal->p_offset = BYTE_GET (external->p_offset);
5041       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
5042       internal->p_paddr  = BYTE_GET (external->p_paddr);
5043       internal->p_filesz = BYTE_GET (external->p_filesz);
5044       internal->p_memsz  = BYTE_GET (external->p_memsz);
5045       internal->p_align  = BYTE_GET (external->p_align);
5046     }
5047
5048   free (phdrs);
5049   return TRUE;
5050 }
5051
5052 /* Returns TRUE if the program headers were read into `program_headers'.  */
5053
5054 static bfd_boolean
5055 get_program_headers (Filedata * filedata)
5056 {
5057   Elf_Internal_Phdr * phdrs;
5058
5059   /* Check cache of prior read.  */
5060   if (filedata->program_headers != NULL)
5061     return TRUE;
5062
5063   /* Be kind to memory checkers by looking for
5064      e_phnum values which we know must be invalid.  */
5065   if (filedata->file_header.e_phnum
5066       * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
5067       >= filedata->file_size)
5068     {
5069       error (_("Too many program headers - %#x - the file is not that big\n"),
5070              filedata->file_header.e_phnum);
5071       return FALSE;
5072     }
5073
5074   phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
5075                                          sizeof (Elf_Internal_Phdr));
5076   if (phdrs == NULL)
5077     {
5078       error (_("Out of memory reading %u program headers\n"),
5079              filedata->file_header.e_phnum);
5080       return FALSE;
5081     }
5082
5083   if (is_32bit_elf
5084       ? get_32bit_program_headers (filedata, phdrs)
5085       : get_64bit_program_headers (filedata, phdrs))
5086     {
5087       filedata->program_headers = phdrs;
5088       return TRUE;
5089     }
5090
5091   free (phdrs);
5092   return FALSE;
5093 }
5094
5095 /* Returns TRUE if the program headers were loaded.  */
5096
5097 static bfd_boolean
5098 process_program_headers (Filedata * filedata)
5099 {
5100   Elf_Internal_Phdr * segment;
5101   unsigned int i;
5102   Elf_Internal_Phdr * previous_load = NULL;
5103
5104   dynamic_addr = 0;
5105   dynamic_size = 0;
5106
5107   if (filedata->file_header.e_phnum == 0)
5108     {
5109       /* PR binutils/12467.  */
5110       if (filedata->file_header.e_phoff != 0)
5111         {
5112           warn (_("possibly corrupt ELF header - it has a non-zero program"
5113                   " header offset, but no program headers\n"));
5114           return FALSE;
5115         }
5116       else if (do_segments)
5117         printf (_("\nThere are no program headers in this file.\n"));
5118       return TRUE;
5119     }
5120
5121   if (do_segments && !do_header)
5122     {
5123       printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
5124       printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
5125       printf (ngettext ("There is %d program header, starting at offset %s\n",
5126                         "There are %d program headers, starting at offset %s\n",
5127                         filedata->file_header.e_phnum),
5128               filedata->file_header.e_phnum,
5129               bfd_vmatoa ("u", filedata->file_header.e_phoff));
5130     }
5131
5132   if (! get_program_headers (filedata))
5133     return TRUE;
5134
5135   if (do_segments)
5136     {
5137       if (filedata->file_header.e_phnum > 1)
5138         printf (_("\nProgram Headers:\n"));
5139       else
5140         printf (_("\nProgram Headers:\n"));
5141
5142       if (is_32bit_elf)
5143         printf
5144           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
5145       else if (do_wide)
5146         printf
5147           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
5148       else
5149         {
5150           printf
5151             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
5152           printf
5153             (_("                 FileSiz            MemSiz              Flags  Align\n"));
5154         }
5155     }
5156
5157   for (i = 0, segment = filedata->program_headers;
5158        i < filedata->file_header.e_phnum;
5159        i++, segment++)
5160     {
5161       if (do_segments)
5162         {
5163           printf ("  %-14.14s ", get_segment_type (filedata, segment->p_type));
5164
5165           if (is_32bit_elf)
5166             {
5167               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5168               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
5169               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
5170               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
5171               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
5172               printf ("%c%c%c ",
5173                       (segment->p_flags & PF_R ? 'R' : ' '),
5174                       (segment->p_flags & PF_W ? 'W' : ' '),
5175                       (segment->p_flags & PF_X ? 'E' : ' '));
5176               printf ("%#lx", (unsigned long) segment->p_align);
5177             }
5178           else if (do_wide)
5179             {
5180               if ((unsigned long) segment->p_offset == segment->p_offset)
5181                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5182               else
5183                 {
5184                   print_vma (segment->p_offset, FULL_HEX);
5185                   putchar (' ');
5186                 }
5187
5188               print_vma (segment->p_vaddr, FULL_HEX);
5189               putchar (' ');
5190               print_vma (segment->p_paddr, FULL_HEX);
5191               putchar (' ');
5192
5193               if ((unsigned long) segment->p_filesz == segment->p_filesz)
5194                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
5195               else
5196                 {
5197                   print_vma (segment->p_filesz, FULL_HEX);
5198                   putchar (' ');
5199                 }
5200
5201               if ((unsigned long) segment->p_memsz == segment->p_memsz)
5202                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5203               else
5204                 {
5205                   print_vma (segment->p_memsz, FULL_HEX);
5206                 }
5207
5208               printf (" %c%c%c ",
5209                       (segment->p_flags & PF_R ? 'R' : ' '),
5210                       (segment->p_flags & PF_W ? 'W' : ' '),
5211                       (segment->p_flags & PF_X ? 'E' : ' '));
5212
5213               if ((unsigned long) segment->p_align == segment->p_align)
5214                 printf ("%#lx", (unsigned long) segment->p_align);
5215               else
5216                 {
5217                   print_vma (segment->p_align, PREFIX_HEX);
5218                 }
5219             }
5220           else
5221             {
5222               print_vma (segment->p_offset, FULL_HEX);
5223               putchar (' ');
5224               print_vma (segment->p_vaddr, FULL_HEX);
5225               putchar (' ');
5226               print_vma (segment->p_paddr, FULL_HEX);
5227               printf ("\n                 ");
5228               print_vma (segment->p_filesz, FULL_HEX);
5229               putchar (' ');
5230               print_vma (segment->p_memsz, FULL_HEX);
5231               printf ("  %c%c%c    ",
5232                       (segment->p_flags & PF_R ? 'R' : ' '),
5233                       (segment->p_flags & PF_W ? 'W' : ' '),
5234                       (segment->p_flags & PF_X ? 'E' : ' '));
5235               print_vma (segment->p_align, PREFIX_HEX);
5236             }
5237
5238           putc ('\n', stdout);
5239         }
5240
5241       switch (segment->p_type)
5242         {
5243         case PT_LOAD:
5244 #if 0 /* Do not warn about out of order PT_LOAD segments.  Although officially
5245          required by the ELF standard, several programs, including the Linux
5246          kernel, make use of non-ordered segments.  */
5247           if (previous_load
5248               && previous_load->p_vaddr > segment->p_vaddr)
5249             error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5250 #endif
5251           if (segment->p_memsz < segment->p_filesz)
5252             error (_("the segment's file size is larger than its memory size\n"));
5253           previous_load = segment;
5254           break;
5255
5256         case PT_PHDR:
5257           /* PR 20815 - Verify that the program header is loaded into memory.  */
5258           if (i > 0 && previous_load != NULL)
5259             error (_("the PHDR segment must occur before any LOAD segment\n"));
5260           if (filedata->file_header.e_machine != EM_PARISC)
5261             {
5262               unsigned int j;
5263
5264               for (j = 1; j < filedata->file_header.e_phnum; j++)
5265                 if (filedata->program_headers[j].p_vaddr <= segment->p_vaddr
5266                     && (filedata->program_headers[j].p_vaddr
5267                         + filedata->program_headers[j].p_memsz)
5268                     >= (segment->p_vaddr + segment->p_filesz))
5269                   break;
5270               if (j == filedata->file_header.e_phnum)
5271                 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5272             }
5273           break;
5274
5275         case PT_DYNAMIC:
5276           if (dynamic_addr)
5277             error (_("more than one dynamic segment\n"));
5278
5279           /* By default, assume that the .dynamic section is the first
5280              section in the DYNAMIC segment.  */
5281           dynamic_addr = segment->p_offset;
5282           dynamic_size = segment->p_filesz;
5283
5284           /* Try to locate the .dynamic section. If there is
5285              a section header table, we can easily locate it.  */
5286           if (filedata->section_headers != NULL)
5287             {
5288               Elf_Internal_Shdr * sec;
5289
5290               sec = find_section (filedata, ".dynamic");
5291               if (sec == NULL || sec->sh_size == 0)
5292                 {
5293                   /* A corresponding .dynamic section is expected, but on
5294                      IA-64/OpenVMS it is OK for it to be missing.  */
5295                   if (!is_ia64_vms (filedata))
5296                     error (_("no .dynamic section in the dynamic segment\n"));
5297                   break;
5298                 }
5299
5300               if (sec->sh_type == SHT_NOBITS)
5301                 {
5302                   dynamic_size = 0;
5303                   break;
5304                 }
5305
5306               dynamic_addr = sec->sh_offset;
5307               dynamic_size = sec->sh_size;
5308
5309               if (dynamic_addr < segment->p_offset
5310                   || dynamic_addr > segment->p_offset + segment->p_filesz)
5311                 warn (_("the .dynamic section is not contained"
5312                         " within the dynamic segment\n"));
5313               else if (dynamic_addr > segment->p_offset)
5314                 warn (_("the .dynamic section is not the first section"
5315                         " in the dynamic segment.\n"));
5316             }
5317
5318           /* PR binutils/17512: Avoid corrupt dynamic section info in the
5319              segment.  Check this after matching against the section headers
5320              so we don't warn on debuginfo file (which have NOBITS .dynamic
5321              sections).  */
5322           if (dynamic_addr > filedata->file_size
5323               || dynamic_size > filedata->file_size - dynamic_addr)
5324             {
5325               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5326               dynamic_addr = dynamic_size = 0;
5327             }
5328           break;
5329
5330         case PT_INTERP:
5331           if (fseek (filedata->handle, archive_file_offset + (long) segment->p_offset,
5332                      SEEK_SET))
5333             error (_("Unable to find program interpreter name\n"));
5334           else
5335             {
5336               char fmt [32];
5337               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5338
5339               if (ret >= (int) sizeof (fmt) || ret < 0)
5340                 error (_("Internal error: failed to create format string to display program interpreter\n"));
5341
5342               program_interpreter[0] = 0;
5343               if (fscanf (filedata->handle, fmt, program_interpreter) <= 0)
5344                 error (_("Unable to read program interpreter name\n"));
5345
5346               if (do_segments)
5347                 printf (_("      [Requesting program interpreter: %s]\n"),
5348                     program_interpreter);
5349             }
5350           break;
5351         }
5352     }
5353
5354   if (do_segments
5355       && filedata->section_headers != NULL
5356       && filedata->string_table != NULL)
5357     {
5358       printf (_("\n Section to Segment mapping:\n"));
5359       printf (_("  Segment Sections...\n"));
5360
5361       for (i = 0; i < filedata->file_header.e_phnum; i++)
5362         {
5363           unsigned int j;
5364           Elf_Internal_Shdr * section;
5365
5366           segment = filedata->program_headers + i;
5367           section = filedata->section_headers + 1;
5368
5369           printf ("   %2.2d     ", i);
5370
5371           for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
5372             {
5373               if (!ELF_TBSS_SPECIAL (section, segment)
5374                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5375                 printf ("%s ", printable_section_name (filedata, section));
5376             }
5377
5378           putc ('\n',stdout);
5379         }
5380     }
5381
5382   return TRUE;
5383 }
5384
5385
5386 /* Find the file offset corresponding to VMA by using the program headers.  */
5387
5388 static long
5389 offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
5390 {
5391   Elf_Internal_Phdr * seg;
5392
5393   if (! get_program_headers (filedata))
5394     {
5395       warn (_("Cannot interpret virtual addresses without program headers.\n"));
5396       return (long) vma;
5397     }
5398
5399   for (seg = filedata->program_headers;
5400        seg < filedata->program_headers + filedata->file_header.e_phnum;
5401        ++seg)
5402     {
5403       if (seg->p_type != PT_LOAD)
5404         continue;
5405
5406       if (vma >= (seg->p_vaddr & -seg->p_align)
5407           && vma + size <= seg->p_vaddr + seg->p_filesz)
5408         return vma - seg->p_vaddr + seg->p_offset;
5409     }
5410
5411   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5412         (unsigned long) vma);
5413   return (long) vma;
5414 }
5415
5416
5417 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5418    If PROBE is true, this is just a probe and we do not generate any error
5419    messages if the load fails.  */
5420
5421 static bfd_boolean
5422 get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
5423 {
5424   Elf32_External_Shdr * shdrs;
5425   Elf_Internal_Shdr *   internal;
5426   unsigned int          i;
5427   unsigned int          size = filedata->file_header.e_shentsize;
5428   unsigned int          num = probe ? 1 : filedata->file_header.e_shnum;
5429
5430   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5431   if (size == 0 || num == 0)
5432     return FALSE;
5433   if (size < sizeof * shdrs)
5434     {
5435       if (! probe)
5436         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5437       return FALSE;
5438     }
5439   if (!probe && size > sizeof * shdrs)
5440     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5441
5442   shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
5443                                             size, num,
5444                                             probe ? NULL : _("section headers"));
5445   if (shdrs == NULL)
5446     return FALSE;
5447
5448   free (filedata->section_headers);
5449   filedata->section_headers = (Elf_Internal_Shdr *)
5450     cmalloc (num, sizeof (Elf_Internal_Shdr));
5451   if (filedata->section_headers == NULL)
5452     {
5453       if (!probe)
5454         error (_("Out of memory reading %u section headers\n"), num);
5455       free (shdrs);
5456       return FALSE;
5457     }
5458
5459   for (i = 0, internal = filedata->section_headers;
5460        i < num;
5461        i++, internal++)
5462     {
5463       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5464       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5465       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5466       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5467       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5468       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5469       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5470       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5471       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5472       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5473       if (!probe && internal->sh_link > num)
5474         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5475       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5476         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5477     }
5478
5479   free (shdrs);
5480   return TRUE;
5481 }
5482
5483 /* Like get_32bit_section_headers, except that it fetches 64-bit headers.  */
5484
5485 static bfd_boolean
5486 get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
5487 {
5488   Elf64_External_Shdr *  shdrs;
5489   Elf_Internal_Shdr *    internal;
5490   unsigned int           i;
5491   unsigned int           size = filedata->file_header.e_shentsize;
5492   unsigned int           num = probe ? 1 : filedata->file_header.e_shnum;
5493
5494   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5495   if (size == 0 || num == 0)
5496     return FALSE;
5497
5498   if (size < sizeof * shdrs)
5499     {
5500       if (! probe)
5501         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5502       return FALSE;
5503     }
5504
5505   if (! probe && size > sizeof * shdrs)
5506     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5507
5508   shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
5509                                             filedata->file_header.e_shoff,
5510                                             size, num,
5511                                             probe ? NULL : _("section headers"));
5512   if (shdrs == NULL)
5513     return FALSE;
5514
5515   free (filedata->section_headers);
5516   filedata->section_headers = (Elf_Internal_Shdr *)
5517     cmalloc (num, sizeof (Elf_Internal_Shdr));
5518   if (filedata->section_headers == NULL)
5519     {
5520       if (! probe)
5521         error (_("Out of memory reading %u section headers\n"), num);
5522       free (shdrs);
5523       return FALSE;
5524     }
5525
5526   for (i = 0, internal = filedata->section_headers;
5527        i < num;
5528        i++, internal++)
5529     {
5530       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5531       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5532       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5533       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5534       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5535       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5536       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5537       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5538       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5539       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5540       if (!probe && internal->sh_link > num)
5541         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5542       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5543         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5544     }
5545
5546   free (shdrs);
5547   return TRUE;
5548 }
5549
5550 static Elf_Internal_Sym *
5551 get_32bit_elf_symbols (Filedata *           filedata,
5552                        Elf_Internal_Shdr *  section,
5553                        unsigned long *      num_syms_return)
5554 {
5555   unsigned long number = 0;
5556   Elf32_External_Sym * esyms = NULL;
5557   Elf_External_Sym_Shndx * shndx = NULL;
5558   Elf_Internal_Sym * isyms = NULL;
5559   Elf_Internal_Sym * psym;
5560   unsigned int j;
5561   elf_section_list * entry;
5562
5563   if (section->sh_size == 0)
5564     {
5565       if (num_syms_return != NULL)
5566         * num_syms_return = 0;
5567       return NULL;
5568     }
5569
5570   /* Run some sanity checks first.  */
5571   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5572     {
5573       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5574              printable_section_name (filedata, section),
5575              (unsigned long) section->sh_entsize);
5576       goto exit_point;
5577     }
5578
5579   if (section->sh_size > filedata->file_size)
5580     {
5581       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5582              printable_section_name (filedata, section),
5583              (unsigned long) section->sh_size);
5584       goto exit_point;
5585     }
5586
5587   number = section->sh_size / section->sh_entsize;
5588
5589   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5590     {
5591       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5592              (unsigned long) section->sh_size,
5593              printable_section_name (filedata, section),
5594              (unsigned long) section->sh_entsize);
5595       goto exit_point;
5596     }
5597
5598   esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5599                                            section->sh_size, _("symbols"));
5600   if (esyms == NULL)
5601     goto exit_point;
5602
5603   shndx = NULL;
5604   for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5605     {
5606       if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5607         continue;
5608
5609       if (shndx != NULL)
5610         {
5611           error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5612           free (shndx);
5613         }
5614
5615       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5616                                                    entry->hdr->sh_offset,
5617                                                    1, entry->hdr->sh_size,
5618                                                    _("symbol table section indices"));
5619       if (shndx == NULL)
5620         goto exit_point;
5621
5622       /* PR17531: file: heap-buffer-overflow */
5623       if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5624         {
5625           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5626                  printable_section_name (filedata, entry->hdr),
5627                  (unsigned long) entry->hdr->sh_size,
5628                  (unsigned long) section->sh_size);
5629           goto exit_point;
5630         }
5631     }
5632
5633   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5634
5635   if (isyms == NULL)
5636     {
5637       error (_("Out of memory reading %lu symbols\n"),
5638              (unsigned long) number);
5639       goto exit_point;
5640     }
5641
5642   for (j = 0, psym = isyms; j < number; j++, psym++)
5643     {
5644       psym->st_name  = BYTE_GET (esyms[j].st_name);
5645       psym->st_value = BYTE_GET (esyms[j].st_value);
5646       psym->st_size  = BYTE_GET (esyms[j].st_size);
5647       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5648       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5649         psym->st_shndx
5650           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5651       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5652         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5653       psym->st_info  = BYTE_GET (esyms[j].st_info);
5654       psym->st_other = BYTE_GET (esyms[j].st_other);
5655     }
5656
5657  exit_point:
5658   free (shndx);
5659   free (esyms);
5660
5661   if (num_syms_return != NULL)
5662     * num_syms_return = isyms == NULL ? 0 : number;
5663
5664   return isyms;
5665 }
5666
5667 static Elf_Internal_Sym *
5668 get_64bit_elf_symbols (Filedata *           filedata,
5669                        Elf_Internal_Shdr *  section,
5670                        unsigned long *      num_syms_return)
5671 {
5672   unsigned long number = 0;
5673   Elf64_External_Sym * esyms = NULL;
5674   Elf_External_Sym_Shndx * shndx = NULL;
5675   Elf_Internal_Sym * isyms = NULL;
5676   Elf_Internal_Sym * psym;
5677   unsigned int j;
5678   elf_section_list * entry;
5679
5680   if (section->sh_size == 0)
5681     {
5682       if (num_syms_return != NULL)
5683         * num_syms_return = 0;
5684       return NULL;
5685     }
5686
5687   /* Run some sanity checks first.  */
5688   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5689     {
5690       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5691              printable_section_name (filedata, section),
5692              (unsigned long) section->sh_entsize);
5693       goto exit_point;
5694     }
5695
5696   if (section->sh_size > filedata->file_size)
5697     {
5698       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5699              printable_section_name (filedata, section),
5700              (unsigned long) section->sh_size);
5701       goto exit_point;
5702     }
5703
5704   number = section->sh_size / section->sh_entsize;
5705
5706   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5707     {
5708       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5709              (unsigned long) section->sh_size,
5710              printable_section_name (filedata, section),
5711              (unsigned long) section->sh_entsize);
5712       goto exit_point;
5713     }
5714
5715   esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5716                                            section->sh_size, _("symbols"));
5717   if (!esyms)
5718     goto exit_point;
5719
5720   shndx = NULL;
5721   for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5722     {
5723       if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5724         continue;
5725
5726       if (shndx != NULL)
5727         {
5728           error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5729           free (shndx);
5730         }
5731
5732       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5733                                                    entry->hdr->sh_offset,
5734                                                    1, entry->hdr->sh_size,
5735                                                    _("symbol table section indices"));
5736       if (shndx == NULL)
5737         goto exit_point;
5738
5739       /* PR17531: file: heap-buffer-overflow */
5740       if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5741         {
5742           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5743                  printable_section_name (filedata, entry->hdr),
5744                  (unsigned long) entry->hdr->sh_size,
5745                  (unsigned long) section->sh_size);
5746           goto exit_point;
5747         }
5748     }
5749
5750   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5751
5752   if (isyms == NULL)
5753     {
5754       error (_("Out of memory reading %lu symbols\n"),
5755              (unsigned long) number);
5756       goto exit_point;
5757     }
5758
5759   for (j = 0, psym = isyms; j < number; j++, psym++)
5760     {
5761       psym->st_name  = BYTE_GET (esyms[j].st_name);
5762       psym->st_info  = BYTE_GET (esyms[j].st_info);
5763       psym->st_other = BYTE_GET (esyms[j].st_other);
5764       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5765
5766       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5767         psym->st_shndx
5768           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5769       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5770         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5771
5772       psym->st_value = BYTE_GET (esyms[j].st_value);
5773       psym->st_size  = BYTE_GET (esyms[j].st_size);
5774     }
5775
5776  exit_point:
5777   free (shndx);
5778   free (esyms);
5779
5780   if (num_syms_return != NULL)
5781     * num_syms_return = isyms == NULL ? 0 : number;
5782
5783   return isyms;
5784 }
5785
5786 static const char *
5787 get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
5788 {
5789   static char buff[1024];
5790   char * p = buff;
5791   unsigned int field_size = is_32bit_elf ? 8 : 16;
5792   signed int sindex;
5793   unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5794   bfd_vma os_flags = 0;
5795   bfd_vma proc_flags = 0;
5796   bfd_vma unknown_flags = 0;
5797   static const struct
5798     {
5799       const char * str;
5800       unsigned int len;
5801     }
5802   flags [] =
5803     {
5804       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5805       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5806       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5807       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5808       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5809       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5810       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5811       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5812       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5813       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5814       /* IA-64 specific.  */
5815       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5816       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5817       /* IA-64 OpenVMS specific.  */
5818       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5819       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5820       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5821       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5822       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5823       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5824       /* Generic.  */
5825       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5826       /* SPARC specific.  */
5827       /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5828       /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5829       /* ARM specific.  */
5830       /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5831       /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5832       /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5833       /* GNU specific.  */
5834       /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5835       /* VLE specific.  */
5836       /* 25 */ { STRING_COMMA_LEN ("VLE") },
5837     };
5838
5839   if (do_section_details)
5840     {
5841       sprintf (buff, "[%*.*lx]: ",
5842                field_size, field_size, (unsigned long) sh_flags);
5843       p += field_size + 4;
5844     }
5845
5846   while (sh_flags)
5847     {
5848       bfd_vma flag;
5849
5850       flag = sh_flags & - sh_flags;
5851       sh_flags &= ~ flag;
5852
5853       if (do_section_details)
5854         {
5855           switch (flag)
5856             {
5857             case SHF_WRITE:             sindex = 0; break;
5858             case SHF_ALLOC:             sindex = 1; break;
5859             case SHF_EXECINSTR:         sindex = 2; break;
5860             case SHF_MERGE:             sindex = 3; break;
5861             case SHF_STRINGS:           sindex = 4; break;
5862             case SHF_INFO_LINK:         sindex = 5; break;
5863             case SHF_LINK_ORDER:        sindex = 6; break;
5864             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5865             case SHF_GROUP:             sindex = 8; break;
5866             case SHF_TLS:               sindex = 9; break;
5867             case SHF_EXCLUDE:           sindex = 18; break;
5868             case SHF_COMPRESSED:        sindex = 20; break;
5869             case SHF_GNU_MBIND:         sindex = 24; break;
5870
5871             default:
5872               sindex = -1;
5873               switch (filedata->file_header.e_machine)
5874                 {
5875                 case EM_IA_64:
5876                   if (flag == SHF_IA_64_SHORT)
5877                     sindex = 10;
5878                   else if (flag == SHF_IA_64_NORECOV)
5879                     sindex = 11;
5880 #ifdef BFD64
5881                   else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5882                     switch (flag)
5883                       {
5884                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5885                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5886                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5887                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5888                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5889                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5890                       default:                        break;
5891                       }
5892 #endif
5893                   break;
5894
5895                 case EM_386:
5896                 case EM_IAMCU:
5897                 case EM_X86_64:
5898                 case EM_L1OM:
5899                 case EM_K1OM:
5900                 case EM_OLD_SPARCV9:
5901                 case EM_SPARC32PLUS:
5902                 case EM_SPARCV9:
5903                 case EM_SPARC:
5904                   if (flag == SHF_ORDERED)
5905                     sindex = 19;
5906                   break;
5907
5908                 case EM_ARM:
5909                   switch (flag)
5910                     {
5911                     case SHF_ENTRYSECT: sindex = 21; break;
5912                     case SHF_ARM_PURECODE: sindex = 22; break;
5913                     case SHF_COMDEF: sindex = 23; break;
5914                     default: break;
5915                     }
5916                   break;
5917                 case EM_PPC:
5918                   if (flag == SHF_PPC_VLE)
5919                     sindex = 25;
5920                   break;
5921
5922                 default:
5923                   break;
5924                 }
5925             }
5926
5927           if (sindex != -1)
5928             {
5929               if (p != buff + field_size + 4)
5930                 {
5931                   if (size < (10 + 2))
5932                     {
5933                       warn (_("Internal error: not enough buffer room for section flag info"));
5934                       return _("<unknown>");
5935                     }
5936                   size -= 2;
5937                   *p++ = ',';
5938                   *p++ = ' ';
5939                 }
5940
5941               size -= flags [sindex].len;
5942               p = stpcpy (p, flags [sindex].str);
5943             }
5944           else if (flag & SHF_MASKOS)
5945             os_flags |= flag;
5946           else if (flag & SHF_MASKPROC)
5947             proc_flags |= flag;
5948           else
5949             unknown_flags |= flag;
5950         }
5951       else
5952         {
5953           switch (flag)
5954             {
5955             case SHF_WRITE:             *p = 'W'; break;
5956             case SHF_ALLOC:             *p = 'A'; break;
5957             case SHF_EXECINSTR:         *p = 'X'; break;
5958             case SHF_MERGE:             *p = 'M'; break;
5959             case SHF_STRINGS:           *p = 'S'; break;
5960             case SHF_INFO_LINK:         *p = 'I'; break;
5961             case SHF_LINK_ORDER:        *p = 'L'; break;
5962             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5963             case SHF_GROUP:             *p = 'G'; break;
5964             case SHF_TLS:               *p = 'T'; break;
5965             case SHF_EXCLUDE:           *p = 'E'; break;
5966             case SHF_COMPRESSED:        *p = 'C'; break;
5967             case SHF_GNU_MBIND:         *p = 'D'; break;
5968
5969             default:
5970               if ((filedata->file_header.e_machine == EM_X86_64
5971                    || filedata->file_header.e_machine == EM_L1OM
5972                    || filedata->file_header.e_machine == EM_K1OM)
5973                   && flag == SHF_X86_64_LARGE)
5974                 *p = 'l';
5975               else if (filedata->file_header.e_machine == EM_ARM
5976                        && flag == SHF_ARM_PURECODE)
5977                   *p = 'y';
5978               else if (filedata->file_header.e_machine == EM_PPC
5979                        && flag == SHF_PPC_VLE)
5980                   *p = 'v';
5981               else if (flag & SHF_MASKOS)
5982                 {
5983                   *p = 'o';
5984                   sh_flags &= ~ SHF_MASKOS;
5985                 }
5986               else if (flag & SHF_MASKPROC)
5987                 {
5988                   *p = 'p';
5989                   sh_flags &= ~ SHF_MASKPROC;
5990                 }
5991               else
5992                 *p = 'x';
5993               break;
5994             }
5995           p++;
5996         }
5997     }
5998
5999   if (do_section_details)
6000     {
6001       if (os_flags)
6002         {
6003           size -= 5 + field_size;
6004           if (p != buff + field_size + 4)
6005             {
6006               if (size < (2 + 1))
6007                 {
6008                   warn (_("Internal error: not enough buffer room for section flag info"));
6009                   return _("<unknown>");
6010                 }
6011               size -= 2;
6012               *p++ = ',';
6013               *p++ = ' ';
6014             }
6015           sprintf (p, "OS (%*.*lx)", field_size, field_size,
6016                    (unsigned long) os_flags);
6017           p += 5 + field_size;
6018         }
6019       if (proc_flags)
6020         {
6021           size -= 7 + field_size;
6022           if (p != buff + field_size + 4)
6023             {
6024               if (size < (2 + 1))
6025                 {
6026                   warn (_("Internal error: not enough buffer room for section flag info"));
6027                   return _("<unknown>");
6028                 }
6029               size -= 2;
6030               *p++ = ',';
6031               *p++ = ' ';
6032             }
6033           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
6034                    (unsigned long) proc_flags);
6035           p += 7 + field_size;
6036         }
6037       if (unknown_flags)
6038         {
6039           size -= 10 + field_size;
6040           if (p != buff + field_size + 4)
6041             {
6042               if (size < (2 + 1))
6043                 {
6044                   warn (_("Internal error: not enough buffer room for section flag info"));
6045                   return _("<unknown>");
6046                 }
6047               size -= 2;
6048               *p++ = ',';
6049               *p++ = ' ';
6050             }
6051           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
6052                    (unsigned long) unknown_flags);
6053           p += 10 + field_size;
6054         }
6055     }
6056
6057   *p = '\0';
6058   return buff;
6059 }
6060
6061 static unsigned int
6062 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
6063 {
6064   if (is_32bit_elf)
6065     {
6066       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
6067
6068       if (size < sizeof (* echdr))
6069         {
6070           error (_("Compressed section is too small even for a compression header\n"));
6071           return 0;
6072         }
6073
6074       chdr->ch_type = BYTE_GET (echdr->ch_type);
6075       chdr->ch_size = BYTE_GET (echdr->ch_size);
6076       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
6077       return sizeof (*echdr);
6078     }
6079   else
6080     {
6081       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
6082
6083       if (size < sizeof (* echdr))
6084         {
6085           error (_("Compressed section is too small even for a compression header\n"));
6086           return 0;
6087         }
6088
6089       chdr->ch_type = BYTE_GET (echdr->ch_type);
6090       chdr->ch_size = BYTE_GET (echdr->ch_size);
6091       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
6092       return sizeof (*echdr);
6093     }
6094 }
6095
6096 static bfd_boolean
6097 process_section_headers (Filedata * filedata)
6098 {
6099   Elf_Internal_Shdr * section;
6100   unsigned int i;
6101
6102   filedata->section_headers = NULL;
6103
6104   if (filedata->file_header.e_shnum == 0)
6105     {
6106       /* PR binutils/12467.  */
6107       if (filedata->file_header.e_shoff != 0)
6108         {
6109           warn (_("possibly corrupt ELF file header - it has a non-zero"
6110                   " section header offset, but no section headers\n"));
6111           return FALSE;
6112         }
6113       else if (do_sections)
6114         printf (_("\nThere are no sections in this file.\n"));
6115
6116       return TRUE;
6117     }
6118
6119   if (do_sections && !do_header)
6120     printf (ngettext ("There is %d section header, "
6121                       "starting at offset 0x%lx:\n",
6122                       "There are %d section headers, "
6123                       "starting at offset 0x%lx:\n",
6124                       filedata->file_header.e_shnum),
6125             filedata->file_header.e_shnum,
6126             (unsigned long) filedata->file_header.e_shoff);
6127
6128   if (is_32bit_elf)
6129     {
6130       if (! get_32bit_section_headers (filedata, FALSE))
6131         return FALSE;
6132     }
6133   else
6134     {
6135       if (! get_64bit_section_headers (filedata, FALSE))
6136         return FALSE;
6137     }
6138
6139   /* Read in the string table, so that we have names to display.  */
6140   if (filedata->file_header.e_shstrndx != SHN_UNDEF
6141        && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
6142     {
6143       section = filedata->section_headers + filedata->file_header.e_shstrndx;
6144
6145       if (section->sh_size != 0)
6146         {
6147           filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
6148                                                       1, section->sh_size,
6149                                                       _("string table"));
6150
6151           filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
6152         }
6153     }
6154
6155   /* Scan the sections for the dynamic symbol table
6156      and dynamic string table and debug sections.  */
6157   dynamic_symbols = NULL;
6158   dynamic_strings = NULL;
6159   dynamic_syminfo = NULL;
6160   symtab_shndx_list = NULL;
6161
6162   eh_addr_size = is_32bit_elf ? 4 : 8;
6163   switch (filedata->file_header.e_machine)
6164     {
6165     case EM_MIPS:
6166     case EM_MIPS_RS3_LE:
6167       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6168          FDE addresses.  However, the ABI also has a semi-official ILP32
6169          variant for which the normal FDE address size rules apply.
6170
6171          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6172          section, where XX is the size of longs in bits.  Unfortunately,
6173          earlier compilers provided no way of distinguishing ILP32 objects
6174          from LP64 objects, so if there's any doubt, we should assume that
6175          the official LP64 form is being used.  */
6176       if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
6177           && find_section (filedata, ".gcc_compiled_long32") == NULL)
6178         eh_addr_size = 8;
6179       break;
6180
6181     case EM_H8_300:
6182     case EM_H8_300H:
6183       switch (filedata->file_header.e_flags & EF_H8_MACH)
6184         {
6185         case E_H8_MACH_H8300:
6186         case E_H8_MACH_H8300HN:
6187         case E_H8_MACH_H8300SN:
6188         case E_H8_MACH_H8300SXN:
6189           eh_addr_size = 2;
6190           break;
6191         case E_H8_MACH_H8300H:
6192         case E_H8_MACH_H8300S:
6193         case E_H8_MACH_H8300SX:
6194           eh_addr_size = 4;
6195           break;
6196         }
6197       break;
6198
6199     case EM_M32C_OLD:
6200     case EM_M32C:
6201       switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
6202         {
6203         case EF_M32C_CPU_M16C:
6204           eh_addr_size = 2;
6205           break;
6206         }
6207       break;
6208     }
6209
6210 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
6211   do                                                                    \
6212     {                                                                   \
6213       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
6214       if (section->sh_entsize != expected_entsize)                      \
6215         {                                                               \
6216           char buf[40];                                                 \
6217           sprintf_vma (buf, section->sh_entsize);                       \
6218           /* Note: coded this way so that there is a single string for  \
6219              translation.  */ \
6220           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6221           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6222                    (unsigned) expected_entsize);                        \
6223           section->sh_entsize = expected_entsize;                       \
6224         }                                                               \
6225     }                                                                   \
6226   while (0)
6227
6228 #define CHECK_ENTSIZE(section, i, type)                                 \
6229   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
6230                         sizeof (Elf64_External_##type))
6231
6232   for (i = 0, section = filedata->section_headers;
6233        i < filedata->file_header.e_shnum;
6234        i++, section++)
6235     {
6236       char * name = SECTION_NAME (section);
6237
6238       if (section->sh_type == SHT_DYNSYM)
6239         {
6240           if (dynamic_symbols != NULL)
6241             {
6242               error (_("File contains multiple dynamic symbol tables\n"));
6243               continue;
6244             }
6245
6246           CHECK_ENTSIZE (section, i, Sym);
6247           dynamic_symbols = GET_ELF_SYMBOLS (filedata, section, & num_dynamic_syms);
6248         }
6249       else if (section->sh_type == SHT_STRTAB
6250                && streq (name, ".dynstr"))
6251         {
6252           if (dynamic_strings != NULL)
6253             {
6254               error (_("File contains multiple dynamic string tables\n"));
6255               continue;
6256             }
6257
6258           dynamic_strings = (char *) get_data (NULL, filedata, section->sh_offset,
6259                                                1, section->sh_size,
6260                                                _("dynamic strings"));
6261           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6262         }
6263       else if (section->sh_type == SHT_SYMTAB_SHNDX)
6264         {
6265           elf_section_list * entry = xmalloc (sizeof * entry);
6266
6267           entry->hdr = section;
6268           entry->next = symtab_shndx_list;
6269           symtab_shndx_list = entry;
6270         }
6271       else if (section->sh_type == SHT_SYMTAB)
6272         CHECK_ENTSIZE (section, i, Sym);
6273       else if (section->sh_type == SHT_GROUP)
6274         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6275       else if (section->sh_type == SHT_REL)
6276         CHECK_ENTSIZE (section, i, Rel);
6277       else if (section->sh_type == SHT_RELA)
6278         CHECK_ENTSIZE (section, i, Rela);
6279       else if ((do_debugging || do_debug_info || do_debug_abbrevs
6280                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6281                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6282                 || do_debug_str || do_debug_loc || do_debug_ranges
6283                 || do_debug_addr || do_debug_cu_index || do_debug_links)
6284                && (const_strneq (name, ".debug_")
6285                    || const_strneq (name, ".zdebug_")))
6286         {
6287           if (name[1] == 'z')
6288             name += sizeof (".zdebug_") - 1;
6289           else
6290             name += sizeof (".debug_") - 1;
6291
6292           if (do_debugging
6293               || (do_debug_info     && const_strneq (name, "info"))
6294               || (do_debug_info     && const_strneq (name, "types"))
6295               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
6296               || (do_debug_lines    && strcmp (name, "line") == 0)
6297               || (do_debug_lines    && const_strneq (name, "line."))
6298               || (do_debug_pubnames && const_strneq (name, "pubnames"))
6299               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6300               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6301               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6302               || (do_debug_aranges  && const_strneq (name, "aranges"))
6303               || (do_debug_ranges   && const_strneq (name, "ranges"))
6304               || (do_debug_ranges   && const_strneq (name, "rnglists"))
6305               || (do_debug_frames   && const_strneq (name, "frame"))
6306               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
6307               || (do_debug_macinfo  && const_strneq (name, "macro"))
6308               || (do_debug_str      && const_strneq (name, "str"))
6309               || (do_debug_loc      && const_strneq (name, "loc"))
6310               || (do_debug_loc      && const_strneq (name, "loclists"))
6311               || (do_debug_addr     && const_strneq (name, "addr"))
6312               || (do_debug_cu_index && const_strneq (name, "cu_index"))
6313               || (do_debug_cu_index && const_strneq (name, "tu_index"))
6314               )
6315             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6316         }
6317       /* Linkonce section to be combined with .debug_info at link time.  */
6318       else if ((do_debugging || do_debug_info)
6319                && const_strneq (name, ".gnu.linkonce.wi."))
6320         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6321       else if (do_debug_frames && streq (name, ".eh_frame"))
6322         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6323       else if (do_gdb_index && (streq (name, ".gdb_index")
6324                                 || streq (name, ".debug_names")))
6325         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6326       /* Trace sections for Itanium VMS.  */
6327       else if ((do_debugging || do_trace_info || do_trace_abbrevs
6328                 || do_trace_aranges)
6329                && const_strneq (name, ".trace_"))
6330         {
6331           name += sizeof (".trace_") - 1;
6332
6333           if (do_debugging
6334               || (do_trace_info     && streq (name, "info"))
6335               || (do_trace_abbrevs  && streq (name, "abbrev"))
6336               || (do_trace_aranges  && streq (name, "aranges"))
6337               )
6338             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6339         }
6340       else if ((do_debugging || do_debug_links)
6341                && (const_strneq (name, ".gnu_debuglink")
6342                    || const_strneq (name, ".gnu_debugaltlink")))
6343         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6344     }
6345
6346   if (! do_sections)
6347     return TRUE;
6348
6349   if (filedata->file_header.e_shnum > 1)
6350     printf (_("\nSection Headers:\n"));
6351   else
6352     printf (_("\nSection Header:\n"));
6353
6354   if (is_32bit_elf)
6355     {
6356       if (do_section_details)
6357         {
6358           printf (_("  [Nr] Name\n"));
6359           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
6360         }
6361       else
6362         printf
6363           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
6364     }
6365   else if (do_wide)
6366     {
6367       if (do_section_details)
6368         {
6369           printf (_("  [Nr] Name\n"));
6370           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
6371         }
6372       else
6373         printf
6374           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
6375     }
6376   else
6377     {
6378       if (do_section_details)
6379         {
6380           printf (_("  [Nr] Name\n"));
6381           printf (_("       Type              Address          Offset            Link\n"));
6382           printf (_("       Size              EntSize          Info              Align\n"));
6383         }
6384       else
6385         {
6386           printf (_("  [Nr] Name              Type             Address           Offset\n"));
6387           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
6388         }
6389     }
6390
6391   if (do_section_details)
6392     printf (_("       Flags\n"));
6393
6394   for (i = 0, section = filedata->section_headers;
6395        i < filedata->file_header.e_shnum;
6396        i++, section++)
6397     {
6398       /* Run some sanity checks on the section header.  */
6399
6400       /* Check the sh_link field.  */
6401       switch (section->sh_type)
6402         {
6403         case SHT_REL:
6404         case SHT_RELA:
6405           if (section->sh_link == 0
6406               && (filedata->file_header.e_type == ET_EXEC
6407                   || filedata->file_header.e_type == ET_DYN))
6408             /* A dynamic relocation section where all entries use a
6409                zero symbol index need not specify a symtab section.  */
6410             break;
6411           /* Fall through.  */
6412         case SHT_SYMTAB_SHNDX:
6413         case SHT_GROUP:
6414         case SHT_HASH:
6415         case SHT_GNU_HASH:
6416         case SHT_GNU_versym:
6417           if (section->sh_link == 0
6418               || section->sh_link >= filedata->file_header.e_shnum
6419               || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6420                   && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6421             warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6422                   i, section->sh_link);
6423           break;
6424
6425         case SHT_DYNAMIC:
6426         case SHT_SYMTAB:
6427         case SHT_DYNSYM:
6428         case SHT_GNU_verneed:
6429         case SHT_GNU_verdef:
6430         case SHT_GNU_LIBLIST:
6431           if (section->sh_link == 0
6432               || section->sh_link >= filedata->file_header.e_shnum
6433               || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6434             warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6435                   i, section->sh_link);
6436           break;
6437
6438         case SHT_INIT_ARRAY:
6439         case SHT_FINI_ARRAY:
6440         case SHT_PREINIT_ARRAY:
6441           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6442             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6443                   i, section->sh_link);
6444           break;
6445
6446         default:
6447           /* FIXME: Add support for target specific section types.  */
6448 #if 0     /* Currently we do not check other section types as there are too
6449              many special cases.  Stab sections for example have a type
6450              of SHT_PROGBITS but an sh_link field that links to the .stabstr
6451              section.  */
6452           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6453             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6454                   i, section->sh_link);
6455 #endif
6456           break;
6457         }
6458
6459       /* Check the sh_info field.  */
6460       switch (section->sh_type)
6461         {
6462         case SHT_REL:
6463         case SHT_RELA:
6464           if (section->sh_info == 0
6465               && (filedata->file_header.e_type == ET_EXEC
6466                   || filedata->file_header.e_type == ET_DYN))
6467             /* Dynamic relocations apply to segments, so they do not
6468                need to specify the section they relocate.  */
6469             break;
6470           if (section->sh_info == 0
6471               || section->sh_info >= filedata->file_header.e_shnum
6472               || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6473                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6474                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6475                   && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6476                   && filedata->section_headers[section->sh_info].sh_type != SHT_FINI_ARRAY
6477                   && filedata->section_headers[section->sh_info].sh_type != SHT_PREINIT_ARRAY
6478                   /* FIXME: Are other section types valid ?  */
6479                   && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6480             warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6481                   i, section->sh_info);
6482           break;
6483
6484         case SHT_DYNAMIC:
6485         case SHT_HASH:
6486         case SHT_SYMTAB_SHNDX:
6487         case SHT_INIT_ARRAY:
6488         case SHT_FINI_ARRAY:
6489         case SHT_PREINIT_ARRAY:
6490           if (section->sh_info != 0)
6491             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6492                   i, section->sh_info);
6493           break;
6494
6495         case SHT_GROUP:
6496         case SHT_SYMTAB:
6497         case SHT_DYNSYM:
6498           /* A symbol index - we assume that it is valid.  */
6499           break;
6500
6501         default:
6502           /* FIXME: Add support for target specific section types.  */
6503           if (section->sh_type == SHT_NOBITS)
6504             /* NOBITS section headers with non-zero sh_info fields can be
6505                created when a binary is stripped of everything but its debug
6506                information.  The stripped sections have their headers
6507                preserved but their types set to SHT_NOBITS.  So do not check
6508                this type of section.  */
6509             ;
6510           else if (section->sh_flags & SHF_INFO_LINK)
6511             {
6512               if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6513                 warn (_("[%2u]: Expected link to another section in info field"), i);
6514             }
6515           else if (section->sh_type < SHT_LOOS
6516                    && (section->sh_flags & SHF_GNU_MBIND) == 0
6517                    && section->sh_info != 0)
6518             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6519                   i, section->sh_info);
6520           break;
6521         }
6522
6523       /* Check the sh_size field.  */
6524       if (section->sh_size > filedata->file_size
6525           && section->sh_type != SHT_NOBITS
6526           && section->sh_type != SHT_NULL
6527           && section->sh_type < SHT_LOOS)
6528         warn (_("Size of section %u is larger than the entire file!\n"), i);
6529
6530       printf ("  [%2u] ", i);
6531       if (do_section_details)
6532         printf ("%s\n      ", printable_section_name (filedata, section));
6533       else
6534         print_symbol (-17, SECTION_NAME (section));
6535
6536       printf (do_wide ? " %-15s " : " %-15.15s ",
6537               get_section_type_name (filedata, section->sh_type));
6538
6539       if (is_32bit_elf)
6540         {
6541           const char * link_too_big = NULL;
6542
6543           print_vma (section->sh_addr, LONG_HEX);
6544
6545           printf ( " %6.6lx %6.6lx %2.2lx",
6546                    (unsigned long) section->sh_offset,
6547                    (unsigned long) section->sh_size,
6548                    (unsigned long) section->sh_entsize);
6549
6550           if (do_section_details)
6551             fputs ("  ", stdout);
6552           else
6553             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6554
6555           if (section->sh_link >= filedata->file_header.e_shnum)
6556             {
6557               link_too_big = "";
6558               /* The sh_link value is out of range.  Normally this indicates
6559                  an error but it can have special values in Solaris binaries.  */
6560               switch (filedata->file_header.e_machine)
6561                 {
6562                 case EM_386:
6563                 case EM_IAMCU:
6564                 case EM_X86_64:
6565                 case EM_L1OM:
6566                 case EM_K1OM:
6567                 case EM_OLD_SPARCV9:
6568                 case EM_SPARC32PLUS:
6569                 case EM_SPARCV9:
6570                 case EM_SPARC:
6571                   if (section->sh_link == (SHN_BEFORE & 0xffff))
6572                     link_too_big = "BEFORE";
6573                   else if (section->sh_link == (SHN_AFTER & 0xffff))
6574                     link_too_big = "AFTER";
6575                   break;
6576                 default:
6577                   break;
6578                 }
6579             }
6580
6581           if (do_section_details)
6582             {
6583               if (link_too_big != NULL && * link_too_big)
6584                 printf ("<%s> ", link_too_big);
6585               else
6586                 printf ("%2u ", section->sh_link);
6587               printf ("%3u %2lu\n", section->sh_info,
6588                       (unsigned long) section->sh_addralign);
6589             }
6590           else
6591             printf ("%2u %3u %2lu\n",
6592                     section->sh_link,
6593                     section->sh_info,
6594                     (unsigned long) section->sh_addralign);
6595
6596           if (link_too_big && ! * link_too_big)
6597             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6598                   i, section->sh_link);
6599         }
6600       else if (do_wide)
6601         {
6602           print_vma (section->sh_addr, LONG_HEX);
6603
6604           if ((long) section->sh_offset == section->sh_offset)
6605             printf (" %6.6lx", (unsigned long) section->sh_offset);
6606           else
6607             {
6608               putchar (' ');
6609               print_vma (section->sh_offset, LONG_HEX);
6610             }
6611
6612           if ((unsigned long) section->sh_size == section->sh_size)
6613             printf (" %6.6lx", (unsigned long) section->sh_size);
6614           else
6615             {
6616               putchar (' ');
6617               print_vma (section->sh_size, LONG_HEX);
6618             }
6619
6620           if ((unsigned long) section->sh_entsize == section->sh_entsize)
6621             printf (" %2.2lx", (unsigned long) section->sh_entsize);
6622           else
6623             {
6624               putchar (' ');
6625               print_vma (section->sh_entsize, LONG_HEX);
6626             }
6627
6628           if (do_section_details)
6629             fputs ("  ", stdout);
6630           else
6631             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6632
6633           printf ("%2u %3u ", section->sh_link, section->sh_info);
6634
6635           if ((unsigned long) section->sh_addralign == section->sh_addralign)
6636             printf ("%2lu\n", (unsigned long) section->sh_addralign);
6637           else
6638             {
6639               print_vma (section->sh_addralign, DEC);
6640               putchar ('\n');
6641             }
6642         }
6643       else if (do_section_details)
6644         {
6645           putchar (' ');
6646           print_vma (section->sh_addr, LONG_HEX);
6647           if ((long) section->sh_offset == section->sh_offset)
6648             printf ("  %16.16lx", (unsigned long) section->sh_offset);
6649           else
6650             {
6651               printf ("  ");
6652               print_vma (section->sh_offset, LONG_HEX);
6653             }
6654           printf ("  %u\n       ", section->sh_link);
6655           print_vma (section->sh_size, LONG_HEX);
6656           putchar (' ');
6657           print_vma (section->sh_entsize, LONG_HEX);
6658
6659           printf ("  %-16u  %lu\n",
6660                   section->sh_info,
6661                   (unsigned long) section->sh_addralign);
6662         }
6663       else
6664         {
6665           putchar (' ');
6666           print_vma (section->sh_addr, LONG_HEX);
6667           if ((long) section->sh_offset == section->sh_offset)
6668             printf ("  %8.8lx", (unsigned long) section->sh_offset);
6669           else
6670             {
6671               printf ("  ");
6672               print_vma (section->sh_offset, LONG_HEX);
6673             }
6674           printf ("\n       ");
6675           print_vma (section->sh_size, LONG_HEX);
6676           printf ("  ");
6677           print_vma (section->sh_entsize, LONG_HEX);
6678
6679           printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6680
6681           printf ("     %2u   %3u     %lu\n",
6682                   section->sh_link,
6683                   section->sh_info,
6684                   (unsigned long) section->sh_addralign);
6685         }
6686
6687       if (do_section_details)
6688         {
6689           printf ("       %s\n", get_elf_section_flags (filedata, section->sh_flags));
6690           if ((section->sh_flags & SHF_COMPRESSED) != 0)
6691             {
6692               /* Minimum section size is 12 bytes for 32-bit compression
6693                  header + 12 bytes for compressed data header.  */
6694               unsigned char buf[24];
6695
6696               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6697               if (get_data (&buf, filedata, section->sh_offset, 1,
6698                             sizeof (buf), _("compression header")))
6699                 {
6700                   Elf_Internal_Chdr chdr;
6701
6702                   (void) get_compression_header (&chdr, buf, sizeof (buf));
6703
6704                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6705                     printf ("       ZLIB, ");
6706                   else
6707                     printf (_("       [<unknown>: 0x%x], "),
6708                             chdr.ch_type);
6709                   print_vma (chdr.ch_size, LONG_HEX);
6710                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6711                 }
6712             }
6713         }
6714     }
6715
6716   if (!do_section_details)
6717     {
6718       /* The ordering of the letters shown here matches the ordering of the
6719          corresponding SHF_xxx values, and hence the order in which these
6720          letters will be displayed to the user.  */
6721       printf (_("Key to Flags:\n\
6722   W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6723   L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6724   C (compressed), x (unknown), o (OS specific), E (exclude),\n  "));
6725       if (filedata->file_header.e_machine == EM_X86_64
6726           || filedata->file_header.e_machine == EM_L1OM
6727           || filedata->file_header.e_machine == EM_K1OM)
6728         printf (_("l (large), "));
6729       else if (filedata->file_header.e_machine == EM_ARM)
6730         printf (_("y (purecode), "));
6731       else if (filedata->file_header.e_machine == EM_PPC)
6732         printf (_("v (VLE), "));
6733       printf ("p (processor specific)\n");
6734     }
6735
6736   return TRUE;
6737 }
6738
6739 static const char *
6740 get_group_flags (unsigned int flags)
6741 {
6742   static char buff[128];
6743
6744   if (flags == 0)
6745     return "";
6746   else if (flags == GRP_COMDAT)
6747     return "COMDAT ";
6748
6749   snprintf (buff, 14, _("[0x%x: "), flags);
6750
6751   flags &= ~ GRP_COMDAT;
6752   if (flags & GRP_MASKOS)
6753     {
6754       strcat (buff, "<OS specific>");
6755       flags &= ~ GRP_MASKOS;
6756     }
6757
6758   if (flags & GRP_MASKPROC)
6759     {
6760       strcat (buff, "<PROC specific>");
6761       flags &= ~ GRP_MASKPROC;
6762     }
6763
6764   if (flags)
6765     strcat (buff, "<unknown>");
6766
6767   strcat (buff, "]");
6768   return buff;
6769 }
6770
6771 static bfd_boolean
6772 process_section_groups (Filedata * filedata)
6773 {
6774   Elf_Internal_Shdr * section;
6775   unsigned int i;
6776   struct group * group;
6777   Elf_Internal_Shdr * symtab_sec;
6778   Elf_Internal_Shdr * strtab_sec;
6779   Elf_Internal_Sym * symtab;
6780   unsigned long num_syms;
6781   char * strtab;
6782   size_t strtab_size;
6783
6784   /* Don't process section groups unless needed.  */
6785   if (!do_unwind && !do_section_groups)
6786     return TRUE;
6787
6788   if (filedata->file_header.e_shnum == 0)
6789     {
6790       if (do_section_groups)
6791         printf (_("\nThere are no sections to group in this file.\n"));
6792
6793       return TRUE;
6794     }
6795
6796   if (filedata->section_headers == NULL)
6797     {
6798       error (_("Section headers are not available!\n"));
6799       /* PR 13622: This can happen with a corrupt ELF header.  */
6800       return FALSE;
6801     }
6802
6803   section_headers_groups = (struct group **) calloc (filedata->file_header.e_shnum,
6804                                                      sizeof (struct group *));
6805
6806   if (section_headers_groups == NULL)
6807     {
6808       error (_("Out of memory reading %u section group headers\n"),
6809              filedata->file_header.e_shnum);
6810       return FALSE;
6811     }
6812
6813   /* Scan the sections for the group section.  */
6814   group_count = 0;
6815   for (i = 0, section = filedata->section_headers;
6816        i < filedata->file_header.e_shnum;
6817        i++, section++)
6818     if (section->sh_type == SHT_GROUP)
6819       group_count++;
6820
6821   if (group_count == 0)
6822     {
6823       if (do_section_groups)
6824         printf (_("\nThere are no section groups in this file.\n"));
6825
6826       return TRUE;
6827     }
6828
6829   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6830
6831   if (section_groups == NULL)
6832     {
6833       error (_("Out of memory reading %lu groups\n"),
6834              (unsigned long) group_count);
6835       return FALSE;
6836     }
6837
6838   symtab_sec = NULL;
6839   strtab_sec = NULL;
6840   symtab = NULL;
6841   num_syms = 0;
6842   strtab = NULL;
6843   strtab_size = 0;
6844   for (i = 0, section = filedata->section_headers, group = section_groups;
6845        i < filedata->file_header.e_shnum;
6846        i++, section++)
6847     {
6848       if (section->sh_type == SHT_GROUP)
6849         {
6850           const char * name = printable_section_name (filedata, section);
6851           const char * group_name;
6852           unsigned char * start;
6853           unsigned char * indices;
6854           unsigned int entry, j, size;
6855           Elf_Internal_Shdr * sec;
6856           Elf_Internal_Sym * sym;
6857
6858           /* Get the symbol table.  */
6859           if (section->sh_link >= filedata->file_header.e_shnum
6860               || ((sec = filedata->section_headers + section->sh_link)->sh_type
6861                   != SHT_SYMTAB))
6862             {
6863               error (_("Bad sh_link in group section `%s'\n"), name);
6864               continue;
6865             }
6866
6867           if (symtab_sec != sec)
6868             {
6869               symtab_sec = sec;
6870               if (symtab)
6871                 free (symtab);
6872               symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
6873             }
6874
6875           if (symtab == NULL)
6876             {
6877               error (_("Corrupt header in group section `%s'\n"), name);
6878               continue;
6879             }
6880
6881           if (section->sh_info >= num_syms)
6882             {
6883               error (_("Bad sh_info in group section `%s'\n"), name);
6884               continue;
6885             }
6886
6887           sym = symtab + section->sh_info;
6888
6889           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6890             {
6891               if (sym->st_shndx == 0
6892                   || sym->st_shndx >= filedata->file_header.e_shnum)
6893                 {
6894                   error (_("Bad sh_info in group section `%s'\n"), name);
6895                   continue;
6896                 }
6897
6898               group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
6899               strtab_sec = NULL;
6900               if (strtab)
6901                 free (strtab);
6902               strtab = NULL;
6903               strtab_size = 0;
6904             }
6905           else
6906             {
6907               /* Get the string table.  */
6908               if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
6909                 {
6910                   strtab_sec = NULL;
6911                   if (strtab)
6912                     free (strtab);
6913                   strtab = NULL;
6914                   strtab_size = 0;
6915                 }
6916               else if (strtab_sec
6917                        != (sec = filedata->section_headers + symtab_sec->sh_link))
6918                 {
6919                   strtab_sec = sec;
6920                   if (strtab)
6921                     free (strtab);
6922
6923                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
6924                                               1, strtab_sec->sh_size,
6925                                               _("string table"));
6926                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6927                 }
6928               group_name = sym->st_name < strtab_size
6929                 ? strtab + sym->st_name : _("<corrupt>");
6930             }
6931
6932           /* PR 17531: file: loop.  */
6933           if (section->sh_entsize > section->sh_size)
6934             {
6935               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6936                      printable_section_name (filedata, section),
6937                      (unsigned long) section->sh_entsize,
6938                      (unsigned long) section->sh_size);
6939               continue;
6940             }
6941
6942           start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
6943                                               1, section->sh_size,
6944                                               _("section data"));
6945           if (start == NULL)
6946             continue;
6947
6948           indices = start;
6949           size = (section->sh_size / section->sh_entsize) - 1;
6950           entry = byte_get (indices, 4);
6951           indices += 4;
6952
6953           if (do_section_groups)
6954             {
6955               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6956                       get_group_flags (entry), i, name, group_name, size);
6957
6958               printf (_("   [Index]    Name\n"));
6959             }
6960
6961           group->group_index = i;
6962
6963           for (j = 0; j < size; j++)
6964             {
6965               struct group_list * g;
6966
6967               entry = byte_get (indices, 4);
6968               indices += 4;
6969
6970               if (entry >= filedata->file_header.e_shnum)
6971                 {
6972                   static unsigned num_group_errors = 0;
6973
6974                   if (num_group_errors ++ < 10)
6975                     {
6976                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6977                              entry, i, filedata->file_header.e_shnum - 1);
6978                       if (num_group_errors == 10)
6979                         warn (_("Further error messages about overlarge group section indices suppressed\n"));
6980                     }
6981                   continue;
6982                 }
6983
6984               if (section_headers_groups [entry] != NULL)
6985                 {
6986                   if (entry)
6987                     {
6988                       static unsigned num_errs = 0;
6989
6990                       if (num_errs ++ < 10)
6991                         {
6992                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6993                                  entry, i,
6994                                  section_headers_groups [entry]->group_index);
6995                           if (num_errs == 10)
6996                             warn (_("Further error messages about already contained group sections suppressed\n"));
6997                         }
6998                       continue;
6999                     }
7000                   else
7001                     {
7002                       /* Intel C/C++ compiler may put section 0 in a
7003                          section group.  We just warn it the first time
7004                          and ignore it afterwards.  */
7005                       static bfd_boolean warned = FALSE;
7006                       if (!warned)
7007                         {
7008                           error (_("section 0 in group section [%5u]\n"),
7009                                  section_headers_groups [entry]->group_index);
7010                           warned = TRUE;
7011                         }
7012                     }
7013                 }
7014
7015               section_headers_groups [entry] = group;
7016
7017               if (do_section_groups)
7018                 {
7019                   sec = filedata->section_headers + entry;
7020                   printf ("   [%5u]   %s\n", entry, printable_section_name (filedata, sec));
7021                 }
7022
7023               g = (struct group_list *) xmalloc (sizeof (struct group_list));
7024               g->section_index = entry;
7025               g->next = group->root;
7026               group->root = g;
7027             }
7028
7029           if (start)
7030             free (start);
7031
7032           group++;
7033         }
7034     }
7035
7036   if (symtab)
7037     free (symtab);
7038   if (strtab)
7039     free (strtab);
7040   return TRUE;
7041 }
7042
7043 /* Data used to display dynamic fixups.  */
7044
7045 struct ia64_vms_dynfixup
7046 {
7047   bfd_vma needed_ident;         /* Library ident number.  */
7048   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
7049   bfd_vma fixup_needed;         /* Index of the library.  */
7050   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
7051   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
7052 };
7053
7054 /* Data used to display dynamic relocations.  */
7055
7056 struct ia64_vms_dynimgrela
7057 {
7058   bfd_vma img_rela_cnt;         /* Number of relocations.  */
7059   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
7060 };
7061
7062 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7063    library).  */
7064
7065 static bfd_boolean
7066 dump_ia64_vms_dynamic_fixups (Filedata *                  filedata,
7067                               struct ia64_vms_dynfixup *  fixup,
7068                               const char *                strtab,
7069                               unsigned int                strtab_sz)
7070 {
7071   Elf64_External_VMS_IMAGE_FIXUP * imfs;
7072   long i;
7073   const char * lib_name;
7074
7075   imfs = get_data (NULL, filedata, dynamic_addr + fixup->fixup_rela_off,
7076                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
7077                    _("dynamic section image fixups"));
7078   if (!imfs)
7079     return FALSE;
7080
7081   if (fixup->needed < strtab_sz)
7082     lib_name = strtab + fixup->needed;
7083   else
7084     {
7085       warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7086             (unsigned long) fixup->needed);
7087       lib_name = "???";
7088     }
7089   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7090           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
7091   printf
7092     (_("Seg Offset           Type                             SymVec DataType\n"));
7093
7094   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
7095     {
7096       unsigned int type;
7097       const char *rtype;
7098
7099       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
7100       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
7101       type = BYTE_GET (imfs [i].type);
7102       rtype = elf_ia64_reloc_type (type);
7103       if (rtype == NULL)
7104         printf (" 0x%08x                       ", type);
7105       else
7106         printf (" %-32s ", rtype);
7107       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
7108       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
7109     }
7110
7111   free (imfs);
7112   return TRUE;
7113 }
7114
7115 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
7116
7117 static bfd_boolean
7118 dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
7119 {
7120   Elf64_External_VMS_IMAGE_RELA *imrs;
7121   long i;
7122
7123   imrs = get_data (NULL, filedata, dynamic_addr + imgrela->img_rela_off,
7124                    1, imgrela->img_rela_cnt * sizeof (*imrs),
7125                    _("dynamic section image relocations"));
7126   if (!imrs)
7127     return FALSE;
7128
7129   printf (_("\nImage relocs\n"));
7130   printf
7131     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
7132
7133   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
7134     {
7135       unsigned int type;
7136       const char *rtype;
7137
7138       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
7139       printf ("%08" BFD_VMA_FMT "x ",
7140               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
7141       type = BYTE_GET (imrs [i].type);
7142       rtype = elf_ia64_reloc_type (type);
7143       if (rtype == NULL)
7144         printf ("0x%08x                      ", type);
7145       else
7146         printf ("%-31s ", rtype);
7147       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
7148       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
7149       printf ("%08" BFD_VMA_FMT "x\n",
7150               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
7151     }
7152
7153   free (imrs);
7154   return TRUE;
7155 }
7156
7157 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
7158
7159 static bfd_boolean
7160 process_ia64_vms_dynamic_relocs (Filedata * filedata)
7161 {
7162   struct ia64_vms_dynfixup fixup;
7163   struct ia64_vms_dynimgrela imgrela;
7164   Elf_Internal_Dyn *entry;
7165   bfd_vma strtab_off = 0;
7166   bfd_vma strtab_sz = 0;
7167   char *strtab = NULL;
7168   bfd_boolean res = TRUE;
7169
7170   memset (&fixup, 0, sizeof (fixup));
7171   memset (&imgrela, 0, sizeof (imgrela));
7172
7173   /* Note: the order of the entries is specified by the OpenVMS specs.  */
7174   for (entry = dynamic_section;
7175        entry < dynamic_section + dynamic_nent;
7176        entry++)
7177     {
7178       switch (entry->d_tag)
7179         {
7180         case DT_IA_64_VMS_STRTAB_OFFSET:
7181           strtab_off = entry->d_un.d_val;
7182           break;
7183         case DT_STRSZ:
7184           strtab_sz = entry->d_un.d_val;
7185           if (strtab == NULL)
7186             strtab = get_data (NULL, filedata, dynamic_addr + strtab_off,
7187                                1, strtab_sz, _("dynamic string section"));
7188           break;
7189
7190         case DT_IA_64_VMS_NEEDED_IDENT:
7191           fixup.needed_ident = entry->d_un.d_val;
7192           break;
7193         case DT_NEEDED:
7194           fixup.needed = entry->d_un.d_val;
7195           break;
7196         case DT_IA_64_VMS_FIXUP_NEEDED:
7197           fixup.fixup_needed = entry->d_un.d_val;
7198           break;
7199         case DT_IA_64_VMS_FIXUP_RELA_CNT:
7200           fixup.fixup_rela_cnt = entry->d_un.d_val;
7201           break;
7202         case DT_IA_64_VMS_FIXUP_RELA_OFF:
7203           fixup.fixup_rela_off = entry->d_un.d_val;
7204           if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7205             res = FALSE;
7206           break;
7207         case DT_IA_64_VMS_IMG_RELA_CNT:
7208           imgrela.img_rela_cnt = entry->d_un.d_val;
7209           break;
7210         case DT_IA_64_VMS_IMG_RELA_OFF:
7211           imgrela.img_rela_off = entry->d_un.d_val;
7212           if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7213             res = FALSE;
7214           break;
7215
7216         default:
7217           break;
7218         }
7219     }
7220
7221   if (strtab != NULL)
7222     free (strtab);
7223
7224   return res;
7225 }
7226
7227 static struct
7228 {
7229   const char * name;
7230   int reloc;
7231   int size;
7232   int rela;
7233 }
7234   dynamic_relocations [] =
7235 {
7236   { "REL", DT_REL, DT_RELSZ, FALSE },
7237   { "RELA", DT_RELA, DT_RELASZ, TRUE },
7238   { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7239 };
7240
7241 /* Process the reloc section.  */
7242
7243 static bfd_boolean
7244 process_relocs (Filedata * filedata)
7245 {
7246   unsigned long rel_size;
7247   unsigned long rel_offset;
7248
7249   if (!do_reloc)
7250     return TRUE;
7251
7252   if (do_using_dynamic)
7253     {
7254       int          is_rela;
7255       const char * name;
7256       bfd_boolean  has_dynamic_reloc;
7257       unsigned int i;
7258
7259       has_dynamic_reloc = FALSE;
7260
7261       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7262         {
7263           is_rela = dynamic_relocations [i].rela;
7264           name = dynamic_relocations [i].name;
7265           rel_size = dynamic_info [dynamic_relocations [i].size];
7266           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7267
7268           if (rel_size)
7269             has_dynamic_reloc = TRUE;
7270
7271           if (is_rela == UNKNOWN)
7272             {
7273               if (dynamic_relocations [i].reloc == DT_JMPREL)
7274                 switch (dynamic_info[DT_PLTREL])
7275                   {
7276                   case DT_REL:
7277                     is_rela = FALSE;
7278                     break;
7279                   case DT_RELA:
7280                     is_rela = TRUE;
7281                     break;
7282                   }
7283             }
7284
7285           if (rel_size)
7286             {
7287               printf
7288                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7289                  name, rel_offset, rel_size);
7290
7291               dump_relocations (filedata,
7292                                 offset_from_vma (filedata, rel_offset, rel_size),
7293                                 rel_size,
7294                                 dynamic_symbols, num_dynamic_syms,
7295                                 dynamic_strings, dynamic_strings_length,
7296                                 is_rela, TRUE /* is_dynamic */);
7297             }
7298         }
7299
7300       if (is_ia64_vms (filedata))
7301         if (process_ia64_vms_dynamic_relocs (filedata))
7302           has_dynamic_reloc = TRUE;
7303
7304       if (! has_dynamic_reloc)
7305         printf (_("\nThere are no dynamic relocations in this file.\n"));
7306     }
7307   else
7308     {
7309       Elf_Internal_Shdr * section;
7310       unsigned long i;
7311       bfd_boolean found = FALSE;
7312
7313       for (i = 0, section = filedata->section_headers;
7314            i < filedata->file_header.e_shnum;
7315            i++, section++)
7316         {
7317           if (   section->sh_type != SHT_RELA
7318               && section->sh_type != SHT_REL)
7319             continue;
7320
7321           rel_offset = section->sh_offset;
7322           rel_size   = section->sh_size;
7323
7324           if (rel_size)
7325             {
7326               Elf_Internal_Shdr * strsec;
7327               int is_rela;
7328               unsigned long num_rela;
7329
7330               printf (_("\nRelocation section "));
7331
7332               if (filedata->string_table == NULL)
7333                 printf ("%d", section->sh_name);
7334               else
7335                 printf ("'%s'", printable_section_name (filedata, section));
7336
7337               num_rela = rel_size / section->sh_entsize;
7338               printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7339                                 " at offset 0x%lx contains %lu entries:\n",
7340                                 num_rela),
7341                       rel_offset, num_rela);
7342
7343               is_rela = section->sh_type == SHT_RELA;
7344
7345               if (section->sh_link != 0
7346                   && section->sh_link < filedata->file_header.e_shnum)
7347                 {
7348                   Elf_Internal_Shdr * symsec;
7349                   Elf_Internal_Sym *  symtab;
7350                   unsigned long nsyms;
7351                   unsigned long strtablen = 0;
7352                   char * strtab = NULL;
7353
7354                   symsec = filedata->section_headers + section->sh_link;
7355                   if (symsec->sh_type != SHT_SYMTAB
7356                       && symsec->sh_type != SHT_DYNSYM)
7357                     continue;
7358
7359                   symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
7360
7361                   if (symtab == NULL)
7362                     continue;
7363
7364                   if (symsec->sh_link != 0
7365                       && symsec->sh_link < filedata->file_header.e_shnum)
7366                     {
7367                       strsec = filedata->section_headers + symsec->sh_link;
7368
7369                       strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7370                                                   1, strsec->sh_size,
7371                                                   _("string table"));
7372                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
7373                     }
7374
7375                   dump_relocations (filedata, rel_offset, rel_size,
7376                                     symtab, nsyms, strtab, strtablen,
7377                                     is_rela,
7378                                     symsec->sh_type == SHT_DYNSYM);
7379                   if (strtab)
7380                     free (strtab);
7381                   free (symtab);
7382                 }
7383               else
7384                 dump_relocations (filedata, rel_offset, rel_size,
7385                                   NULL, 0, NULL, 0, is_rela,
7386                                   FALSE /* is_dynamic */);
7387
7388               found = TRUE;
7389             }
7390         }
7391
7392       if (! found)
7393         {
7394           /* Users sometimes forget the -D option, so try to be helpful.  */
7395           for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7396             {
7397               if (dynamic_info [dynamic_relocations [i].size])
7398                 {
7399                   printf (_("\nThere are no static relocations in this file."));
7400                   printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7401
7402                   break;
7403                 }
7404             }
7405           if (i == ARRAY_SIZE (dynamic_relocations))
7406             printf (_("\nThere are no relocations in this file.\n"));
7407         }
7408     }
7409
7410   return TRUE;
7411 }
7412
7413 /* An absolute address consists of a section and an offset.  If the
7414    section is NULL, the offset itself is the address, otherwise, the
7415    address equals to LOAD_ADDRESS(section) + offset.  */
7416
7417 struct absaddr
7418 {
7419   unsigned short section;
7420   bfd_vma offset;
7421 };
7422
7423 /* Find the nearest symbol at or below ADDR.  Returns the symbol
7424    name, if found, and the offset from the symbol to ADDR.  */
7425
7426 static void
7427 find_symbol_for_address (Filedata *          filedata,
7428                          Elf_Internal_Sym *  symtab,
7429                          unsigned long       nsyms,
7430                          const char *        strtab,
7431                          unsigned long       strtab_size,
7432                          struct absaddr      addr,
7433                          const char **       symname,
7434                          bfd_vma *           offset)
7435 {
7436   bfd_vma dist = 0x100000;
7437   Elf_Internal_Sym * sym;
7438   Elf_Internal_Sym * beg;
7439   Elf_Internal_Sym * end;
7440   Elf_Internal_Sym * best = NULL;
7441
7442   REMOVE_ARCH_BITS (addr.offset);
7443   beg = symtab;
7444   end = symtab + nsyms;
7445
7446   while (beg < end)
7447     {
7448       bfd_vma value;
7449
7450       sym = beg + (end - beg) / 2;
7451
7452       value = sym->st_value;
7453       REMOVE_ARCH_BITS (value);
7454
7455       if (sym->st_name != 0
7456           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7457           && addr.offset >= value
7458           && addr.offset - value < dist)
7459         {
7460           best = sym;
7461           dist = addr.offset - value;
7462           if (!dist)
7463             break;
7464         }
7465
7466       if (addr.offset < value)
7467         end = sym;
7468       else
7469         beg = sym + 1;
7470     }
7471
7472   if (best)
7473     {
7474       *symname = (best->st_name >= strtab_size
7475                   ? _("<corrupt>") : strtab + best->st_name);
7476       *offset = dist;
7477       return;
7478     }
7479
7480   *symname = NULL;
7481   *offset = addr.offset;
7482 }
7483
7484 static /* signed */ int
7485 symcmp (const void *p, const void *q)
7486 {
7487   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7488   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7489
7490   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7491 }
7492
7493 /* Process the unwind section.  */
7494
7495 #include "unwind-ia64.h"
7496
7497 struct ia64_unw_table_entry
7498 {
7499   struct absaddr start;
7500   struct absaddr end;
7501   struct absaddr info;
7502 };
7503
7504 struct ia64_unw_aux_info
7505 {
7506   struct ia64_unw_table_entry * table;          /* Unwind table.  */
7507   unsigned long                 table_len;      /* Length of unwind table.  */
7508   unsigned char *               info;           /* Unwind info.  */
7509   unsigned long                 info_size;      /* Size of unwind info.  */
7510   bfd_vma                       info_addr;      /* Starting address of unwind info.  */
7511   bfd_vma                       seg_base;       /* Starting address of segment.  */
7512   Elf_Internal_Sym *            symtab;         /* The symbol table.  */
7513   unsigned long                 nsyms;          /* Number of symbols.  */
7514   Elf_Internal_Sym *            funtab;         /* Sorted table of STT_FUNC symbols.  */
7515   unsigned long                 nfuns;          /* Number of entries in funtab.  */
7516   char *                        strtab;         /* The string table.  */
7517   unsigned long                 strtab_size;    /* Size of string table.  */
7518 };
7519
7520 static bfd_boolean
7521 dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7522 {
7523   struct ia64_unw_table_entry * tp;
7524   unsigned long j, nfuns;
7525   int in_body;
7526   bfd_boolean res = TRUE;
7527
7528   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7529   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7530     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7531       aux->funtab[nfuns++] = aux->symtab[j];
7532   aux->nfuns = nfuns;
7533   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7534
7535   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7536     {
7537       bfd_vma stamp;
7538       bfd_vma offset;
7539       const unsigned char * dp;
7540       const unsigned char * head;
7541       const unsigned char * end;
7542       const char * procname;
7543
7544       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7545                                aux->strtab_size, tp->start, &procname, &offset);
7546
7547       fputs ("\n<", stdout);
7548
7549       if (procname)
7550         {
7551           fputs (procname, stdout);
7552
7553           if (offset)
7554             printf ("+%lx", (unsigned long) offset);
7555         }
7556
7557       fputs (">: [", stdout);
7558       print_vma (tp->start.offset, PREFIX_HEX);
7559       fputc ('-', stdout);
7560       print_vma (tp->end.offset, PREFIX_HEX);
7561       printf ("], info at +0x%lx\n",
7562               (unsigned long) (tp->info.offset - aux->seg_base));
7563
7564       /* PR 17531: file: 86232b32.  */
7565       if (aux->info == NULL)
7566         continue;
7567
7568       offset = tp->info.offset;
7569       if (tp->info.section)
7570         {
7571           if (tp->info.section >= filedata->file_header.e_shnum)
7572             {
7573               warn (_("Invalid section %u in table entry %ld\n"),
7574                     tp->info.section, (long) (tp - aux->table));
7575               res = FALSE;
7576               continue;
7577             }
7578           offset += filedata->section_headers[tp->info.section].sh_addr;
7579         }
7580       offset -= aux->info_addr;
7581       /* PR 17531: file: 0997b4d1.  */
7582       if (offset >= aux->info_size
7583           || aux->info_size - offset < 8)
7584         {
7585           warn (_("Invalid offset %lx in table entry %ld\n"),
7586                 (long) tp->info.offset, (long) (tp - aux->table));
7587           res = FALSE;
7588           continue;
7589         }
7590
7591       head = aux->info + offset;
7592       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7593
7594       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7595               (unsigned) UNW_VER (stamp),
7596               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7597               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7598               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7599               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7600
7601       if (UNW_VER (stamp) != 1)
7602         {
7603           printf (_("\tUnknown version.\n"));
7604           continue;
7605         }
7606
7607       in_body = 0;
7608       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7609       /* PR 17531: file: 16ceda89.  */
7610       if (end > aux->info + aux->info_size)
7611         end = aux->info + aux->info_size;
7612       for (dp = head + 8; dp < end;)
7613         dp = unw_decode (dp, in_body, & in_body, end);
7614     }
7615
7616   free (aux->funtab);
7617
7618   return res;
7619 }
7620
7621 static bfd_boolean
7622 slurp_ia64_unwind_table (Filedata *                  filedata,
7623                          struct ia64_unw_aux_info *  aux,
7624                          Elf_Internal_Shdr *         sec)
7625 {
7626   unsigned long size, nrelas, i;
7627   Elf_Internal_Phdr * seg;
7628   struct ia64_unw_table_entry * tep;
7629   Elf_Internal_Shdr * relsec;
7630   Elf_Internal_Rela * rela;
7631   Elf_Internal_Rela * rp;
7632   unsigned char * table;
7633   unsigned char * tp;
7634   Elf_Internal_Sym * sym;
7635   const char * relname;
7636
7637   aux->table_len = 0;
7638
7639   /* First, find the starting address of the segment that includes
7640      this section: */
7641
7642   if (filedata->file_header.e_phnum)
7643     {
7644       if (! get_program_headers (filedata))
7645           return FALSE;
7646
7647       for (seg = filedata->program_headers;
7648            seg < filedata->program_headers + filedata->file_header.e_phnum;
7649            ++seg)
7650         {
7651           if (seg->p_type != PT_LOAD)
7652             continue;
7653
7654           if (sec->sh_addr >= seg->p_vaddr
7655               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7656             {
7657               aux->seg_base = seg->p_vaddr;
7658               break;
7659             }
7660         }
7661     }
7662
7663   /* Second, build the unwind table from the contents of the unwind section:  */
7664   size = sec->sh_size;
7665   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7666                                       _("unwind table"));
7667   if (!table)
7668     return FALSE;
7669
7670   aux->table_len = size / (3 * eh_addr_size);
7671   aux->table = (struct ia64_unw_table_entry *)
7672     xcmalloc (aux->table_len, sizeof (aux->table[0]));
7673   tep = aux->table;
7674
7675   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7676     {
7677       tep->start.section = SHN_UNDEF;
7678       tep->end.section   = SHN_UNDEF;
7679       tep->info.section  = SHN_UNDEF;
7680       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7681       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7682       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7683       tep->start.offset += aux->seg_base;
7684       tep->end.offset   += aux->seg_base;
7685       tep->info.offset  += aux->seg_base;
7686     }
7687   free (table);
7688
7689   /* Third, apply any relocations to the unwind table:  */
7690   for (relsec = filedata->section_headers;
7691        relsec < filedata->section_headers + filedata->file_header.e_shnum;
7692        ++relsec)
7693     {
7694       if (relsec->sh_type != SHT_RELA
7695           || relsec->sh_info >= filedata->file_header.e_shnum
7696           || filedata->section_headers + relsec->sh_info != sec)
7697         continue;
7698
7699       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7700                               & rela, & nrelas))
7701         {
7702           free (aux->table);
7703           aux->table = NULL;
7704           aux->table_len = 0;
7705           return FALSE;
7706         }
7707
7708       for (rp = rela; rp < rela + nrelas; ++rp)
7709         {
7710           unsigned int sym_ndx;
7711           unsigned int r_type = get_reloc_type (filedata, rp->r_info);
7712           relname = elf_ia64_reloc_type (r_type);
7713
7714           /* PR 17531: file: 9fa67536.  */
7715           if (relname == NULL)
7716             {
7717               warn (_("Skipping unknown relocation type: %u\n"), r_type);
7718               continue;
7719             }
7720
7721           if (! const_strneq (relname, "R_IA64_SEGREL"))
7722             {
7723               warn (_("Skipping unexpected relocation type: %s\n"), relname);
7724               continue;
7725             }
7726
7727           i = rp->r_offset / (3 * eh_addr_size);
7728
7729           /* PR 17531: file: 5bc8d9bf.  */
7730           if (i >= aux->table_len)
7731             {
7732               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7733               continue;
7734             }
7735
7736           sym_ndx = get_reloc_symindex (rp->r_info);
7737           if (sym_ndx >= aux->nsyms)
7738             {
7739               warn (_("Skipping reloc with invalid symbol index: %u\n"),
7740                     sym_ndx);
7741               continue;
7742             }
7743           sym = aux->symtab + sym_ndx;
7744
7745           switch (rp->r_offset / eh_addr_size % 3)
7746             {
7747             case 0:
7748               aux->table[i].start.section = sym->st_shndx;
7749               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
7750               break;
7751             case 1:
7752               aux->table[i].end.section   = sym->st_shndx;
7753               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
7754               break;
7755             case 2:
7756               aux->table[i].info.section  = sym->st_shndx;
7757               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
7758               break;
7759             default:
7760               break;
7761             }
7762         }
7763
7764       free (rela);
7765     }
7766
7767   return TRUE;
7768 }
7769
7770 static bfd_boolean
7771 ia64_process_unwind (Filedata * filedata)
7772 {
7773   Elf_Internal_Shdr * sec;
7774   Elf_Internal_Shdr * unwsec = NULL;
7775   Elf_Internal_Shdr * strsec;
7776   unsigned long i, unwcount = 0, unwstart = 0;
7777   struct ia64_unw_aux_info aux;
7778   bfd_boolean res = TRUE;
7779
7780   memset (& aux, 0, sizeof (aux));
7781
7782   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7783     {
7784       if (sec->sh_type == SHT_SYMTAB
7785           && sec->sh_link < filedata->file_header.e_shnum)
7786         {
7787           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
7788
7789           strsec = filedata->section_headers + sec->sh_link;
7790           if (aux.strtab != NULL)
7791             {
7792               error (_("Multiple auxillary string tables encountered\n"));
7793               free (aux.strtab);
7794               res = FALSE;
7795             }
7796           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7797                                           1, strsec->sh_size,
7798                                           _("string table"));
7799           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7800         }
7801       else if (sec->sh_type == SHT_IA_64_UNWIND)
7802         unwcount++;
7803     }
7804
7805   if (!unwcount)
7806     printf (_("\nThere are no unwind sections in this file.\n"));
7807
7808   while (unwcount-- > 0)
7809     {
7810       char * suffix;
7811       size_t len, len2;
7812
7813       for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7814            i < filedata->file_header.e_shnum; ++i, ++sec)
7815         if (sec->sh_type == SHT_IA_64_UNWIND)
7816           {
7817             unwsec = sec;
7818             break;
7819           }
7820       /* We have already counted the number of SHT_IA64_UNWIND
7821          sections so the loop above should never fail.  */
7822       assert (unwsec != NULL);
7823
7824       unwstart = i + 1;
7825       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7826
7827       if ((unwsec->sh_flags & SHF_GROUP) != 0)
7828         {
7829           /* We need to find which section group it is in.  */
7830           struct group_list * g;
7831
7832           if (section_headers_groups == NULL
7833               || section_headers_groups [i] == NULL)
7834             i = filedata->file_header.e_shnum;
7835           else
7836             {
7837               g = section_headers_groups [i]->root;
7838
7839               for (; g != NULL; g = g->next)
7840                 {
7841                   sec = filedata->section_headers + g->section_index;
7842
7843                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7844                     break;
7845                 }
7846
7847               if (g == NULL)
7848                 i = filedata->file_header.e_shnum;
7849             }
7850         }
7851       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7852         {
7853           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
7854           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7855           suffix = SECTION_NAME (unwsec) + len;
7856           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7857                ++i, ++sec)
7858             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7859                 && streq (SECTION_NAME (sec) + len2, suffix))
7860               break;
7861         }
7862       else
7863         {
7864           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7865              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
7866           len = sizeof (ELF_STRING_ia64_unwind) - 1;
7867           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7868           suffix = "";
7869           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7870             suffix = SECTION_NAME (unwsec) + len;
7871           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7872                ++i, ++sec)
7873             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7874                 && streq (SECTION_NAME (sec) + len2, suffix))
7875               break;
7876         }
7877
7878       if (i == filedata->file_header.e_shnum)
7879         {
7880           printf (_("\nCould not find unwind info section for "));
7881
7882           if (filedata->string_table == NULL)
7883             printf ("%d", unwsec->sh_name);
7884           else
7885             printf ("'%s'", printable_section_name (filedata, unwsec));
7886         }
7887       else
7888         {
7889           aux.info_addr = sec->sh_addr;
7890           aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
7891                                                  sec->sh_size,
7892                                                  _("unwind info"));
7893           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7894
7895           printf (_("\nUnwind section "));
7896
7897           if (filedata->string_table == NULL)
7898             printf ("%d", unwsec->sh_name);
7899           else
7900             printf ("'%s'", printable_section_name (filedata, unwsec));
7901
7902           printf (_(" at offset 0x%lx contains %lu entries:\n"),
7903                   (unsigned long) unwsec->sh_offset,
7904                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7905
7906           if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
7907               && aux.table_len > 0)
7908             dump_ia64_unwind (filedata, & aux);
7909
7910           if (aux.table)
7911             free ((char *) aux.table);
7912           if (aux.info)
7913             free ((char *) aux.info);
7914           aux.table = NULL;
7915           aux.info = NULL;
7916         }
7917     }
7918
7919   if (aux.symtab)
7920     free (aux.symtab);
7921   if (aux.strtab)
7922     free ((char *) aux.strtab);
7923
7924   return res;
7925 }
7926
7927 struct hppa_unw_table_entry
7928 {
7929   struct absaddr start;
7930   struct absaddr end;
7931   unsigned int Cannot_unwind:1;                 /* 0 */
7932   unsigned int Millicode:1;                     /* 1 */
7933   unsigned int Millicode_save_sr0:1;            /* 2 */
7934   unsigned int Region_description:2;            /* 3..4 */
7935   unsigned int reserved1:1;                     /* 5 */
7936   unsigned int Entry_SR:1;                      /* 6 */
7937   unsigned int Entry_FR:4;     /* Number saved     7..10 */
7938   unsigned int Entry_GR:5;     /* Number saved     11..15 */
7939   unsigned int Args_stored:1;                   /* 16 */
7940   unsigned int Variable_Frame:1;                /* 17 */
7941   unsigned int Separate_Package_Body:1;         /* 18 */
7942   unsigned int Frame_Extension_Millicode:1;     /* 19 */
7943   unsigned int Stack_Overflow_Check:1;          /* 20 */
7944   unsigned int Two_Instruction_SP_Increment:1;  /* 21 */
7945   unsigned int Ada_Region:1;                    /* 22 */
7946   unsigned int cxx_info:1;                      /* 23 */
7947   unsigned int cxx_try_catch:1;                 /* 24 */
7948   unsigned int sched_entry_seq:1;               /* 25 */
7949   unsigned int reserved2:1;                     /* 26 */
7950   unsigned int Save_SP:1;                       /* 27 */
7951   unsigned int Save_RP:1;                       /* 28 */
7952   unsigned int Save_MRP_in_frame:1;             /* 29 */
7953   unsigned int extn_ptr_defined:1;              /* 30 */
7954   unsigned int Cleanup_defined:1;               /* 31 */
7955
7956   unsigned int MPE_XL_interrupt_marker:1;       /* 0 */
7957   unsigned int HP_UX_interrupt_marker:1;        /* 1 */
7958   unsigned int Large_frame:1;                   /* 2 */
7959   unsigned int Pseudo_SP_Set:1;                 /* 3 */
7960   unsigned int reserved4:1;                     /* 4 */
7961   unsigned int Total_frame_size:27;             /* 5..31 */
7962 };
7963
7964 struct hppa_unw_aux_info
7965 {
7966   struct hppa_unw_table_entry *  table;         /* Unwind table.  */
7967   unsigned long                  table_len;     /* Length of unwind table.  */
7968   bfd_vma                        seg_base;      /* Starting address of segment.  */
7969   Elf_Internal_Sym *             symtab;        /* The symbol table.  */
7970   unsigned long                  nsyms;         /* Number of symbols.  */
7971   Elf_Internal_Sym *             funtab;        /* Sorted table of STT_FUNC symbols.  */
7972   unsigned long                  nfuns;         /* Number of entries in funtab.  */
7973   char *                         strtab;        /* The string table.  */
7974   unsigned long                  strtab_size;   /* Size of string table.  */
7975 };
7976
7977 static bfd_boolean
7978 dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
7979 {
7980   struct hppa_unw_table_entry * tp;
7981   unsigned long j, nfuns;
7982   bfd_boolean res = TRUE;
7983
7984   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7985   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7986     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7987       aux->funtab[nfuns++] = aux->symtab[j];
7988   aux->nfuns = nfuns;
7989   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7990
7991   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7992     {
7993       bfd_vma offset;
7994       const char * procname;
7995
7996       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7997                                aux->strtab_size, tp->start, &procname,
7998                                &offset);
7999
8000       fputs ("\n<", stdout);
8001
8002       if (procname)
8003         {
8004           fputs (procname, stdout);
8005
8006           if (offset)
8007             printf ("+%lx", (unsigned long) offset);
8008         }
8009
8010       fputs (">: [", stdout);
8011       print_vma (tp->start.offset, PREFIX_HEX);
8012       fputc ('-', stdout);
8013       print_vma (tp->end.offset, PREFIX_HEX);
8014       printf ("]\n\t");
8015
8016 #define PF(_m) if (tp->_m) printf (#_m " ");
8017 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8018       PF(Cannot_unwind);
8019       PF(Millicode);
8020       PF(Millicode_save_sr0);
8021       /* PV(Region_description);  */
8022       PF(Entry_SR);
8023       PV(Entry_FR);
8024       PV(Entry_GR);
8025       PF(Args_stored);
8026       PF(Variable_Frame);
8027       PF(Separate_Package_Body);
8028       PF(Frame_Extension_Millicode);
8029       PF(Stack_Overflow_Check);
8030       PF(Two_Instruction_SP_Increment);
8031       PF(Ada_Region);
8032       PF(cxx_info);
8033       PF(cxx_try_catch);
8034       PF(sched_entry_seq);
8035       PF(Save_SP);
8036       PF(Save_RP);
8037       PF(Save_MRP_in_frame);
8038       PF(extn_ptr_defined);
8039       PF(Cleanup_defined);
8040       PF(MPE_XL_interrupt_marker);
8041       PF(HP_UX_interrupt_marker);
8042       PF(Large_frame);
8043       PF(Pseudo_SP_Set);
8044       PV(Total_frame_size);
8045 #undef PF
8046 #undef PV
8047     }
8048
8049   printf ("\n");
8050
8051   free (aux->funtab);
8052
8053   return res;
8054 }
8055
8056 static bfd_boolean
8057 slurp_hppa_unwind_table (Filedata *                  filedata,
8058                          struct hppa_unw_aux_info *  aux,
8059                          Elf_Internal_Shdr *         sec)
8060 {
8061   unsigned long size, unw_ent_size, nentries, nrelas, i;
8062   Elf_Internal_Phdr * seg;
8063   struct hppa_unw_table_entry * tep;
8064   Elf_Internal_Shdr * relsec;
8065   Elf_Internal_Rela * rela;
8066   Elf_Internal_Rela * rp;
8067   unsigned char * table;
8068   unsigned char * tp;
8069   Elf_Internal_Sym * sym;
8070   const char * relname;
8071
8072   /* First, find the starting address of the segment that includes
8073      this section.  */
8074   if (filedata->file_header.e_phnum)
8075     {
8076       if (! get_program_headers (filedata))
8077         return FALSE;
8078
8079       for (seg = filedata->program_headers;
8080            seg < filedata->program_headers + filedata->file_header.e_phnum;
8081            ++seg)
8082         {
8083           if (seg->p_type != PT_LOAD)
8084             continue;
8085
8086           if (sec->sh_addr >= seg->p_vaddr
8087               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
8088             {
8089               aux->seg_base = seg->p_vaddr;
8090               break;
8091             }
8092         }
8093     }
8094
8095   /* Second, build the unwind table from the contents of the unwind
8096      section.  */
8097   size = sec->sh_size;
8098   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
8099                                       _("unwind table"));
8100   if (!table)
8101     return FALSE;
8102
8103   unw_ent_size = 16;
8104   nentries = size / unw_ent_size;
8105   size = unw_ent_size * nentries;
8106
8107   tep = aux->table = (struct hppa_unw_table_entry *)
8108       xcmalloc (nentries, sizeof (aux->table[0]));
8109
8110   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
8111     {
8112       unsigned int tmp1, tmp2;
8113
8114       tep->start.section = SHN_UNDEF;
8115       tep->end.section   = SHN_UNDEF;
8116
8117       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
8118       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
8119       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
8120       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
8121
8122       tep->start.offset += aux->seg_base;
8123       tep->end.offset   += aux->seg_base;
8124
8125       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
8126       tep->Millicode = (tmp1 >> 30) & 0x1;
8127       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
8128       tep->Region_description = (tmp1 >> 27) & 0x3;
8129       tep->reserved1 = (tmp1 >> 26) & 0x1;
8130       tep->Entry_SR = (tmp1 >> 25) & 0x1;
8131       tep->Entry_FR = (tmp1 >> 21) & 0xf;
8132       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
8133       tep->Args_stored = (tmp1 >> 15) & 0x1;
8134       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
8135       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
8136       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
8137       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
8138       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
8139       tep->Ada_Region = (tmp1 >> 9) & 0x1;
8140       tep->cxx_info = (tmp1 >> 8) & 0x1;
8141       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
8142       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
8143       tep->reserved2 = (tmp1 >> 5) & 0x1;
8144       tep->Save_SP = (tmp1 >> 4) & 0x1;
8145       tep->Save_RP = (tmp1 >> 3) & 0x1;
8146       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
8147       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
8148       tep->Cleanup_defined = tmp1 & 0x1;
8149
8150       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
8151       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
8152       tep->Large_frame = (tmp2 >> 29) & 0x1;
8153       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
8154       tep->reserved4 = (tmp2 >> 27) & 0x1;
8155       tep->Total_frame_size = tmp2 & 0x7ffffff;
8156     }
8157   free (table);
8158
8159   /* Third, apply any relocations to the unwind table.  */
8160   for (relsec = filedata->section_headers;
8161        relsec < filedata->section_headers + filedata->file_header.e_shnum;
8162        ++relsec)
8163     {
8164       if (relsec->sh_type != SHT_RELA
8165           || relsec->sh_info >= filedata->file_header.e_shnum
8166           || filedata->section_headers + relsec->sh_info != sec)
8167         continue;
8168
8169       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
8170                               & rela, & nrelas))
8171         return FALSE;
8172
8173       for (rp = rela; rp < rela + nrelas; ++rp)
8174         {
8175           unsigned int sym_ndx;
8176           unsigned int r_type = get_reloc_type (filedata, rp->r_info);
8177           relname = elf_hppa_reloc_type (r_type);
8178
8179           if (relname == NULL)
8180             {
8181               warn (_("Skipping unknown relocation type: %u\n"), r_type);
8182               continue;
8183             }
8184
8185           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
8186           if (! const_strneq (relname, "R_PARISC_SEGREL"))
8187             {
8188               warn (_("Skipping unexpected relocation type: %s\n"), relname);
8189               continue;
8190             }
8191
8192           i = rp->r_offset / unw_ent_size;
8193           if (i >= aux->table_len)
8194             {
8195               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
8196               continue;
8197             }
8198
8199           sym_ndx = get_reloc_symindex (rp->r_info);
8200           if (sym_ndx >= aux->nsyms)
8201             {
8202               warn (_("Skipping reloc with invalid symbol index: %u\n"),
8203                     sym_ndx);
8204               continue;
8205             }
8206           sym = aux->symtab + sym_ndx;
8207
8208           switch ((rp->r_offset % unw_ent_size) / 4)
8209             {
8210             case 0:
8211               aux->table[i].start.section = sym->st_shndx;
8212               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
8213               break;
8214             case 1:
8215               aux->table[i].end.section   = sym->st_shndx;
8216               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
8217               break;
8218             default:
8219               break;
8220             }
8221         }
8222
8223       free (rela);
8224     }
8225
8226   aux->table_len = nentries;
8227
8228   return TRUE;
8229 }
8230
8231 static bfd_boolean
8232 hppa_process_unwind (Filedata * filedata)
8233 {
8234   struct hppa_unw_aux_info aux;
8235   Elf_Internal_Shdr * unwsec = NULL;
8236   Elf_Internal_Shdr * strsec;
8237   Elf_Internal_Shdr * sec;
8238   unsigned long i;
8239   bfd_boolean res = TRUE;
8240
8241   if (filedata->string_table == NULL)
8242     return FALSE;
8243
8244   memset (& aux, 0, sizeof (aux));
8245
8246   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8247     {
8248       if (sec->sh_type == SHT_SYMTAB
8249           && sec->sh_link < filedata->file_header.e_shnum)
8250         {
8251           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
8252
8253           strsec = filedata->section_headers + sec->sh_link;
8254           if (aux.strtab != NULL)
8255             {
8256               error (_("Multiple auxillary string tables encountered\n"));
8257               free (aux.strtab);
8258               res = FALSE;
8259             }
8260           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
8261                                           1, strsec->sh_size,
8262                                           _("string table"));
8263           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8264         }
8265       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8266         unwsec = sec;
8267     }
8268
8269   if (!unwsec)
8270     printf (_("\nThere are no unwind sections in this file.\n"));
8271
8272   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8273     {
8274       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8275         {
8276           unsigned long num_unwind = sec->sh_size / 16;
8277
8278           printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8279                             "contains %lu entry:\n",
8280                             "\nUnwind section '%s' at offset 0x%lx "
8281                             "contains %lu entries:\n",
8282                             num_unwind),
8283                   printable_section_name (filedata, sec),
8284                   (unsigned long) sec->sh_offset,
8285                   num_unwind);
8286
8287           if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8288             res = FALSE;
8289
8290           if (res && aux.table_len > 0)
8291             {
8292               if (! dump_hppa_unwind (filedata, &aux))
8293                 res = FALSE;
8294             }
8295
8296           if (aux.table)
8297             free ((char *) aux.table);
8298           aux.table = NULL;
8299         }
8300     }
8301
8302   if (aux.symtab)
8303     free (aux.symtab);
8304   if (aux.strtab)
8305     free ((char *) aux.strtab);
8306
8307   return res;
8308 }
8309
8310 struct arm_section
8311 {
8312   unsigned char *      data;            /* The unwind data.  */
8313   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
8314   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
8315   unsigned long        nrelas;          /* The number of relocations.  */
8316   unsigned int         rel_type;        /* REL or RELA ?  */
8317   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
8318 };
8319
8320 struct arm_unw_aux_info
8321 {
8322   Filedata *          filedata;         /* The file containing the unwind sections.  */
8323   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
8324   unsigned long       nsyms;            /* Number of symbols.  */
8325   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
8326   unsigned long       nfuns;            /* Number of these symbols.  */
8327   char *              strtab;           /* The file's string table.  */
8328   unsigned long       strtab_size;      /* Size of string table.  */
8329 };
8330
8331 static const char *
8332 arm_print_vma_and_name (Filedata *                 filedata,
8333                         struct arm_unw_aux_info *  aux,
8334                         bfd_vma                    fn,
8335                         struct absaddr             addr)
8336 {
8337   const char *procname;
8338   bfd_vma sym_offset;
8339
8340   if (addr.section == SHN_UNDEF)
8341     addr.offset = fn;
8342
8343   find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8344                            aux->strtab_size, addr, &procname,
8345                            &sym_offset);
8346
8347   print_vma (fn, PREFIX_HEX);
8348
8349   if (procname)
8350     {
8351       fputs (" <", stdout);
8352       fputs (procname, stdout);
8353
8354       if (sym_offset)
8355         printf ("+0x%lx", (unsigned long) sym_offset);
8356       fputc ('>', stdout);
8357     }
8358
8359   return procname;
8360 }
8361
8362 static void
8363 arm_free_section (struct arm_section *arm_sec)
8364 {
8365   if (arm_sec->data != NULL)
8366     free (arm_sec->data);
8367
8368   if (arm_sec->rela != NULL)
8369     free (arm_sec->rela);
8370 }
8371
8372 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8373       cached section and install SEC instead.
8374    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8375       and return its valued in * WORDP, relocating if necessary.
8376    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8377       relocation's offset in ADDR.
8378    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8379       into the string table of the symbol associated with the reloc.  If no
8380       reloc was applied store -1 there.
8381    5) Return TRUE upon success, FALSE otherwise.  */
8382
8383 static bfd_boolean
8384 get_unwind_section_word (Filedata *                 filedata,
8385                          struct arm_unw_aux_info *  aux,
8386                          struct arm_section *       arm_sec,
8387                          Elf_Internal_Shdr *        sec,
8388                          bfd_vma                    word_offset,
8389                          unsigned int *             wordp,
8390                          struct absaddr *           addr,
8391                          bfd_vma *                  sym_name)
8392 {
8393   Elf_Internal_Rela *rp;
8394   Elf_Internal_Sym *sym;
8395   const char * relname;
8396   unsigned int word;
8397   bfd_boolean wrapped;
8398
8399   if (sec == NULL || arm_sec == NULL)
8400     return FALSE;
8401
8402   addr->section = SHN_UNDEF;
8403   addr->offset = 0;
8404
8405   if (sym_name != NULL)
8406     *sym_name = (bfd_vma) -1;
8407
8408   /* If necessary, update the section cache.  */
8409   if (sec != arm_sec->sec)
8410     {
8411       Elf_Internal_Shdr *relsec;
8412
8413       arm_free_section (arm_sec);
8414
8415       arm_sec->sec = sec;
8416       arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8417                                 sec->sh_size, _("unwind data"));
8418       arm_sec->rela = NULL;
8419       arm_sec->nrelas = 0;
8420
8421       for (relsec = filedata->section_headers;
8422            relsec < filedata->section_headers + filedata->file_header.e_shnum;
8423            ++relsec)
8424         {
8425           if (relsec->sh_info >= filedata->file_header.e_shnum
8426               || filedata->section_headers + relsec->sh_info != sec
8427               /* PR 15745: Check the section type as well.  */
8428               || (relsec->sh_type != SHT_REL
8429                   && relsec->sh_type != SHT_RELA))
8430             continue;
8431
8432           arm_sec->rel_type = relsec->sh_type;
8433           if (relsec->sh_type == SHT_REL)
8434             {
8435               if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8436                                      relsec->sh_size,
8437                                      & arm_sec->rela, & arm_sec->nrelas))
8438                 return FALSE;
8439             }
8440           else /* relsec->sh_type == SHT_RELA */
8441             {
8442               if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8443                                       relsec->sh_size,
8444                                       & arm_sec->rela, & arm_sec->nrelas))
8445                 return FALSE;
8446             }
8447           break;
8448         }
8449
8450       arm_sec->next_rela = arm_sec->rela;
8451     }
8452
8453   /* If there is no unwind data we can do nothing.  */
8454   if (arm_sec->data == NULL)
8455     return FALSE;
8456
8457   /* If the offset is invalid then fail.  */
8458   if (/* PR 21343 *//* PR 18879 */
8459       sec->sh_size < 4
8460       || word_offset > (sec->sh_size - 4)
8461       || ((bfd_signed_vma) word_offset) < 0)
8462     return FALSE;
8463
8464   /* Get the word at the required offset.  */
8465   word = byte_get (arm_sec->data + word_offset, 4);
8466
8467   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
8468   if (arm_sec->rela == NULL)
8469     {
8470       * wordp = word;
8471       return TRUE;
8472     }
8473
8474   /* Look through the relocs to find the one that applies to the provided offset.  */
8475   wrapped = FALSE;
8476   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8477     {
8478       bfd_vma prelval, offset;
8479
8480       if (rp->r_offset > word_offset && !wrapped)
8481         {
8482           rp = arm_sec->rela;
8483           wrapped = TRUE;
8484         }
8485       if (rp->r_offset > word_offset)
8486         break;
8487
8488       if (rp->r_offset & 3)
8489         {
8490           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8491                 (unsigned long) rp->r_offset);
8492           continue;
8493         }
8494
8495       if (rp->r_offset < word_offset)
8496         continue;
8497
8498       /* PR 17531: file: 027-161405-0.004  */
8499       if (aux->symtab == NULL)
8500         continue;
8501
8502       if (arm_sec->rel_type == SHT_REL)
8503         {
8504           offset = word & 0x7fffffff;
8505           if (offset & 0x40000000)
8506             offset |= ~ (bfd_vma) 0x7fffffff;
8507         }
8508       else if (arm_sec->rel_type == SHT_RELA)
8509         offset = rp->r_addend;
8510       else
8511         {
8512           error (_("Unknown section relocation type %d encountered\n"),
8513                  arm_sec->rel_type);
8514           break;
8515         }
8516
8517       /* PR 17531 file: 027-1241568-0.004.  */
8518       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8519         {
8520           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8521                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8522           break;
8523         }
8524
8525       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8526       offset += sym->st_value;
8527       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8528
8529       /* Check that we are processing the expected reloc type.  */
8530       if (filedata->file_header.e_machine == EM_ARM)
8531         {
8532           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8533           if (relname == NULL)
8534             {
8535               warn (_("Skipping unknown ARM relocation type: %d\n"),
8536                     (int) ELF32_R_TYPE (rp->r_info));
8537               continue;
8538             }
8539
8540           if (streq (relname, "R_ARM_NONE"))
8541               continue;
8542
8543           if (! streq (relname, "R_ARM_PREL31"))
8544             {
8545               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8546               continue;
8547             }
8548         }
8549       else if (filedata->file_header.e_machine == EM_TI_C6000)
8550         {
8551           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8552           if (relname == NULL)
8553             {
8554               warn (_("Skipping unknown C6000 relocation type: %d\n"),
8555                     (int) ELF32_R_TYPE (rp->r_info));
8556               continue;
8557             }
8558
8559           if (streq (relname, "R_C6000_NONE"))
8560             continue;
8561
8562           if (! streq (relname, "R_C6000_PREL31"))
8563             {
8564               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8565               continue;
8566             }
8567
8568           prelval >>= 1;
8569         }
8570       else
8571         {
8572           /* This function currently only supports ARM and TI unwinders.  */
8573           warn (_("Only TI and ARM unwinders are currently supported\n"));
8574           break;
8575         }
8576
8577       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8578       addr->section = sym->st_shndx;
8579       addr->offset = offset;
8580
8581       if (sym_name)
8582         * sym_name = sym->st_name;
8583       break;
8584     }
8585
8586   *wordp = word;
8587   arm_sec->next_rela = rp;
8588
8589   return TRUE;
8590 }
8591
8592 static const char *tic6x_unwind_regnames[16] =
8593 {
8594   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8595   "A14", "A13", "A12", "A11", "A10",
8596   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8597 };
8598
8599 static void
8600 decode_tic6x_unwind_regmask (unsigned int mask)
8601 {
8602   int i;
8603
8604   for (i = 12; mask; mask >>= 1, i--)
8605     {
8606       if (mask & 1)
8607         {
8608           fputs (tic6x_unwind_regnames[i], stdout);
8609           if (mask > 1)
8610             fputs (", ", stdout);
8611         }
8612     }
8613 }
8614
8615 #define ADVANCE                                                 \
8616   if (remaining == 0 && more_words)                             \
8617     {                                                           \
8618       data_offset += 4;                                         \
8619       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec,     \
8620                                      data_offset, & word, & addr, NULL))        \
8621         return FALSE;                                           \
8622       remaining = 4;                                            \
8623       more_words--;                                             \
8624     }                                                           \
8625
8626 #define GET_OP(OP)                      \
8627   ADVANCE;                              \
8628   if (remaining)                        \
8629     {                                   \
8630       remaining--;                      \
8631       (OP) = word >> 24;                \
8632       word <<= 8;                       \
8633     }                                   \
8634   else                                  \
8635     {                                   \
8636       printf (_("[Truncated opcode]\n"));       \
8637       return FALSE;                     \
8638     }                                   \
8639   printf ("0x%02x ", OP)
8640
8641 static bfd_boolean
8642 decode_arm_unwind_bytecode (Filedata *                 filedata,
8643                             struct arm_unw_aux_info *  aux,
8644                             unsigned int               word,
8645                             unsigned int               remaining,
8646                             unsigned int               more_words,
8647                             bfd_vma                    data_offset,
8648                             Elf_Internal_Shdr *        data_sec,
8649                             struct arm_section *       data_arm_sec)
8650 {
8651   struct absaddr addr;
8652   bfd_boolean res = TRUE;
8653
8654   /* Decode the unwinding instructions.  */
8655   while (1)
8656     {
8657       unsigned int op, op2;
8658
8659       ADVANCE;
8660       if (remaining == 0)
8661         break;
8662       remaining--;
8663       op = word >> 24;
8664       word <<= 8;
8665
8666       printf ("  0x%02x ", op);
8667
8668       if ((op & 0xc0) == 0x00)
8669         {
8670           int offset = ((op & 0x3f) << 2) + 4;
8671
8672           printf ("     vsp = vsp + %d", offset);
8673         }
8674       else if ((op & 0xc0) == 0x40)
8675         {
8676           int offset = ((op & 0x3f) << 2) + 4;
8677
8678           printf ("     vsp = vsp - %d", offset);
8679         }
8680       else if ((op & 0xf0) == 0x80)
8681         {
8682           GET_OP (op2);
8683           if (op == 0x80 && op2 == 0)
8684             printf (_("Refuse to unwind"));
8685           else
8686             {
8687               unsigned int mask = ((op & 0x0f) << 8) | op2;
8688               bfd_boolean first = TRUE;
8689               int i;
8690
8691               printf ("pop {");
8692               for (i = 0; i < 12; i++)
8693                 if (mask & (1 << i))
8694                   {
8695                     if (first)
8696                       first = FALSE;
8697                     else
8698                       printf (", ");
8699                     printf ("r%d", 4 + i);
8700                   }
8701               printf ("}");
8702             }
8703         }
8704       else if ((op & 0xf0) == 0x90)
8705         {
8706           if (op == 0x9d || op == 0x9f)
8707             printf (_("     [Reserved]"));
8708           else
8709             printf ("     vsp = r%d", op & 0x0f);
8710         }
8711       else if ((op & 0xf0) == 0xa0)
8712         {
8713           int end = 4 + (op & 0x07);
8714           bfd_boolean first = TRUE;
8715           int i;
8716
8717           printf ("     pop {");
8718           for (i = 4; i <= end; i++)
8719             {
8720               if (first)
8721                 first = FALSE;
8722               else
8723                 printf (", ");
8724               printf ("r%d", i);
8725             }
8726           if (op & 0x08)
8727             {
8728               if (!first)
8729                 printf (", ");
8730               printf ("r14");
8731             }
8732           printf ("}");
8733         }
8734       else if (op == 0xb0)
8735         printf (_("     finish"));
8736       else if (op == 0xb1)
8737         {
8738           GET_OP (op2);
8739           if (op2 == 0 || (op2 & 0xf0) != 0)
8740             printf (_("[Spare]"));
8741           else
8742             {
8743               unsigned int mask = op2 & 0x0f;
8744               bfd_boolean first = TRUE;
8745               int i;
8746
8747               printf ("pop {");
8748               for (i = 0; i < 12; i++)
8749                 if (mask & (1 << i))
8750                   {
8751                     if (first)
8752                       first = FALSE;
8753                     else
8754                       printf (", ");
8755                     printf ("r%d", i);
8756                   }
8757               printf ("}");
8758             }
8759         }
8760       else if (op == 0xb2)
8761         {
8762           unsigned char buf[9];
8763           unsigned int i, len;
8764           unsigned long offset;
8765
8766           for (i = 0; i < sizeof (buf); i++)
8767             {
8768               GET_OP (buf[i]);
8769               if ((buf[i] & 0x80) == 0)
8770                 break;
8771             }
8772           if (i == sizeof (buf))
8773             {
8774               error (_("corrupt change to vsp"));
8775               res = FALSE;
8776             }
8777           else
8778             {
8779               offset = read_uleb128 (buf, &len, buf + i + 1);
8780               assert (len == i + 1);
8781               offset = offset * 4 + 0x204;
8782               printf ("vsp = vsp + %ld", offset);
8783             }
8784         }
8785       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8786         {
8787           unsigned int first, last;
8788
8789           GET_OP (op2);
8790           first = op2 >> 4;
8791           last = op2 & 0x0f;
8792           if (op == 0xc8)
8793             first = first + 16;
8794           printf ("pop {D%d", first);
8795           if (last)
8796             printf ("-D%d", first + last);
8797           printf ("}");
8798         }
8799       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8800         {
8801           unsigned int count = op & 0x07;
8802
8803           printf ("pop {D8");
8804           if (count)
8805             printf ("-D%d", 8 + count);
8806           printf ("}");
8807         }
8808       else if (op >= 0xc0 && op <= 0xc5)
8809         {
8810           unsigned int count = op & 0x07;
8811
8812           printf ("     pop {wR10");
8813           if (count)
8814             printf ("-wR%d", 10 + count);
8815           printf ("}");
8816         }
8817       else if (op == 0xc6)
8818         {
8819           unsigned int first, last;
8820
8821           GET_OP (op2);
8822           first = op2 >> 4;
8823           last = op2 & 0x0f;
8824           printf ("pop {wR%d", first);
8825           if (last)
8826             printf ("-wR%d", first + last);
8827           printf ("}");
8828         }
8829       else if (op == 0xc7)
8830         {
8831           GET_OP (op2);
8832           if (op2 == 0 || (op2 & 0xf0) != 0)
8833             printf (_("[Spare]"));
8834           else
8835             {
8836               unsigned int mask = op2 & 0x0f;
8837               bfd_boolean first = TRUE;
8838               int i;
8839
8840               printf ("pop {");
8841               for (i = 0; i < 4; i++)
8842                 if (mask & (1 << i))
8843                   {
8844                     if (first)
8845                       first = FALSE;
8846                     else
8847                       printf (", ");
8848                     printf ("wCGR%d", i);
8849                   }
8850               printf ("}");
8851             }
8852         }
8853       else
8854         {
8855           printf (_("     [unsupported opcode]"));
8856           res = FALSE;
8857         }
8858
8859       printf ("\n");
8860     }
8861
8862   return res;
8863 }
8864
8865 static bfd_boolean
8866 decode_tic6x_unwind_bytecode (Filedata *                 filedata,
8867                               struct arm_unw_aux_info *  aux,
8868                               unsigned int               word,
8869                               unsigned int               remaining,
8870                               unsigned int               more_words,
8871                               bfd_vma                    data_offset,
8872                               Elf_Internal_Shdr *        data_sec,
8873                               struct arm_section *       data_arm_sec)
8874 {
8875   struct absaddr addr;
8876
8877   /* Decode the unwinding instructions.  */
8878   while (1)
8879     {
8880       unsigned int op, op2;
8881
8882       ADVANCE;
8883       if (remaining == 0)
8884         break;
8885       remaining--;
8886       op = word >> 24;
8887       word <<= 8;
8888
8889       printf ("  0x%02x ", op);
8890
8891       if ((op & 0xc0) == 0x00)
8892         {
8893           int offset = ((op & 0x3f) << 3) + 8;
8894           printf ("     sp = sp + %d", offset);
8895         }
8896       else if ((op & 0xc0) == 0x80)
8897         {
8898           GET_OP (op2);
8899           if (op == 0x80 && op2 == 0)
8900             printf (_("Refuse to unwind"));
8901           else
8902             {
8903               unsigned int mask = ((op & 0x1f) << 8) | op2;
8904               if (op & 0x20)
8905                 printf ("pop compact {");
8906               else
8907                 printf ("pop {");
8908
8909               decode_tic6x_unwind_regmask (mask);
8910               printf("}");
8911             }
8912         }
8913       else if ((op & 0xf0) == 0xc0)
8914         {
8915           unsigned int reg;
8916           unsigned int nregs;
8917           unsigned int i;
8918           const char *name;
8919           struct
8920           {
8921             unsigned int offset;
8922             unsigned int reg;
8923           } regpos[16];
8924
8925           /* Scan entire instruction first so that GET_OP output is not
8926              interleaved with disassembly.  */
8927           nregs = 0;
8928           for (i = 0; nregs < (op & 0xf); i++)
8929             {
8930               GET_OP (op2);
8931               reg = op2 >> 4;
8932               if (reg != 0xf)
8933                 {
8934                   regpos[nregs].offset = i * 2;
8935                   regpos[nregs].reg = reg;
8936                   nregs++;
8937                 }
8938
8939               reg = op2 & 0xf;
8940               if (reg != 0xf)
8941                 {
8942                   regpos[nregs].offset = i * 2 + 1;
8943                   regpos[nregs].reg = reg;
8944                   nregs++;
8945                 }
8946             }
8947
8948           printf (_("pop frame {"));
8949           if (nregs == 0)
8950             {
8951               printf (_("*corrupt* - no registers specified"));
8952             }
8953           else
8954             {
8955               reg = nregs - 1;
8956               for (i = i * 2; i > 0; i--)
8957                 {
8958                   if (regpos[reg].offset == i - 1)
8959                     {
8960                       name = tic6x_unwind_regnames[regpos[reg].reg];
8961                       if (reg > 0)
8962                         reg--;
8963                     }
8964                   else
8965                     name = _("[pad]");
8966
8967                   fputs (name, stdout);
8968                   if (i > 1)
8969                     printf (", ");
8970                 }
8971             }
8972
8973           printf ("}");
8974         }
8975       else if (op == 0xd0)
8976         printf ("     MOV FP, SP");
8977       else if (op == 0xd1)
8978         printf ("     __c6xabi_pop_rts");
8979       else if (op == 0xd2)
8980         {
8981           unsigned char buf[9];
8982           unsigned int i, len;
8983           unsigned long offset;
8984
8985           for (i = 0; i < sizeof (buf); i++)
8986             {
8987               GET_OP (buf[i]);
8988               if ((buf[i] & 0x80) == 0)
8989                 break;
8990             }
8991           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8992           if (i == sizeof (buf))
8993             {
8994               warn (_("Corrupt stack pointer adjustment detected\n"));
8995               return FALSE;
8996             }
8997
8998           offset = read_uleb128 (buf, &len, buf + i + 1);
8999           assert (len == i + 1);
9000           offset = offset * 8 + 0x408;
9001           printf (_("sp = sp + %ld"), offset);
9002         }
9003       else if ((op & 0xf0) == 0xe0)
9004         {
9005           if ((op & 0x0f) == 7)
9006             printf ("     RETURN");
9007           else
9008             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
9009         }
9010       else
9011         {
9012           printf (_("     [unsupported opcode]"));
9013         }
9014       putchar ('\n');
9015     }
9016
9017   return TRUE;
9018 }
9019
9020 static bfd_vma
9021 arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
9022 {
9023   bfd_vma offset;
9024
9025   offset = word & 0x7fffffff;
9026   if (offset & 0x40000000)
9027     offset |= ~ (bfd_vma) 0x7fffffff;
9028
9029   if (filedata->file_header.e_machine == EM_TI_C6000)
9030     offset <<= 1;
9031
9032   return offset + where;
9033 }
9034
9035 static bfd_boolean
9036 decode_arm_unwind (Filedata *                 filedata,
9037                    struct arm_unw_aux_info *  aux,
9038                    unsigned int               word,
9039                    unsigned int               remaining,
9040                    bfd_vma                    data_offset,
9041                    Elf_Internal_Shdr *        data_sec,
9042                    struct arm_section *       data_arm_sec)
9043 {
9044   int per_index;
9045   unsigned int more_words = 0;
9046   struct absaddr addr;
9047   bfd_vma sym_name = (bfd_vma) -1;
9048   bfd_boolean res = TRUE;
9049
9050   if (remaining == 0)
9051     {
9052       /* Fetch the first word.
9053          Note - when decoding an object file the address extracted
9054          here will always be 0.  So we also pass in the sym_name
9055          parameter so that we can find the symbol associated with
9056          the personality routine.  */
9057       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
9058                                      & word, & addr, & sym_name))
9059         return FALSE;
9060
9061       remaining = 4;
9062     }
9063   else
9064     {
9065       addr.section = SHN_UNDEF;
9066       addr.offset = 0;
9067     }
9068
9069   if ((word & 0x80000000) == 0)
9070     {
9071       /* Expand prel31 for personality routine.  */
9072       bfd_vma fn;
9073       const char *procname;
9074
9075       fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
9076       printf (_("  Personality routine: "));
9077       if (fn == 0
9078           && addr.section == SHN_UNDEF && addr.offset == 0
9079           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
9080         {
9081           procname = aux->strtab + sym_name;
9082           print_vma (fn, PREFIX_HEX);
9083           if (procname)
9084             {
9085               fputs (" <", stdout);
9086               fputs (procname, stdout);
9087               fputc ('>', stdout);
9088             }
9089         }
9090       else
9091         procname = arm_print_vma_and_name (filedata, aux, fn, addr);
9092       fputc ('\n', stdout);
9093
9094       /* The GCC personality routines use the standard compact
9095          encoding, starting with one byte giving the number of
9096          words.  */
9097       if (procname != NULL
9098           && (const_strneq (procname, "__gcc_personality_v0")
9099               || const_strneq (procname, "__gxx_personality_v0")
9100               || const_strneq (procname, "__gcj_personality_v0")
9101               || const_strneq (procname, "__gnu_objc_personality_v0")))
9102         {
9103           remaining = 0;
9104           more_words = 1;
9105           ADVANCE;
9106           if (!remaining)
9107             {
9108               printf (_("  [Truncated data]\n"));
9109               return FALSE;
9110             }
9111           more_words = word >> 24;
9112           word <<= 8;
9113           remaining--;
9114           per_index = -1;
9115         }
9116       else
9117         return TRUE;
9118     }
9119   else
9120     {
9121       /* ARM EHABI Section 6.3:
9122
9123          An exception-handling table entry for the compact model looks like:
9124
9125            31 30-28 27-24 23-0
9126            -- ----- ----- ----
9127             1   0   index Data for personalityRoutine[index]    */
9128
9129       if (filedata->file_header.e_machine == EM_ARM
9130           && (word & 0x70000000))
9131         {
9132           warn (_("Corrupt ARM compact model table entry: %x \n"), word);
9133           res = FALSE;
9134         }
9135
9136       per_index = (word >> 24) & 0x7f;
9137       printf (_("  Compact model index: %d\n"), per_index);
9138       if (per_index == 0)
9139         {
9140           more_words = 0;
9141           word <<= 8;
9142           remaining--;
9143         }
9144       else if (per_index < 3)
9145         {
9146           more_words = (word >> 16) & 0xff;
9147           word <<= 16;
9148           remaining -= 2;
9149         }
9150     }
9151
9152   switch (filedata->file_header.e_machine)
9153     {
9154     case EM_ARM:
9155       if (per_index < 3)
9156         {
9157           if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
9158                                             data_offset, data_sec, data_arm_sec))
9159             res = FALSE;
9160         }
9161       else
9162         {
9163           warn (_("Unknown ARM compact model index encountered\n"));
9164           printf (_("  [reserved]\n"));
9165           res = FALSE;
9166         }
9167       break;
9168
9169     case EM_TI_C6000:
9170       if (per_index < 3)
9171         {
9172           if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
9173                                               data_offset, data_sec, data_arm_sec))
9174             res = FALSE;
9175         }
9176       else if (per_index < 5)
9177         {
9178           if (((word >> 17) & 0x7f) == 0x7f)
9179             printf (_("  Restore stack from frame pointer\n"));
9180           else
9181             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
9182           printf (_("  Registers restored: "));
9183           if (per_index == 4)
9184             printf (" (compact) ");
9185           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
9186           putchar ('\n');
9187           printf (_("  Return register: %s\n"),
9188                   tic6x_unwind_regnames[word & 0xf]);
9189         }
9190       else
9191         printf (_("  [reserved (%d)]\n"), per_index);
9192       break;
9193
9194     default:
9195       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9196              filedata->file_header.e_machine);
9197       res = FALSE;
9198     }
9199
9200   /* Decode the descriptors.  Not implemented.  */
9201
9202   return res;
9203 }
9204
9205 static bfd_boolean
9206 dump_arm_unwind (Filedata *                 filedata,
9207                  struct arm_unw_aux_info *  aux,
9208                  Elf_Internal_Shdr *        exidx_sec)
9209 {
9210   struct arm_section exidx_arm_sec, extab_arm_sec;
9211   unsigned int i, exidx_len;
9212   unsigned long j, nfuns;
9213   bfd_boolean res = TRUE;
9214
9215   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
9216   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
9217   exidx_len = exidx_sec->sh_size / 8;
9218
9219   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
9220   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
9221     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
9222       aux->funtab[nfuns++] = aux->symtab[j];
9223   aux->nfuns = nfuns;
9224   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
9225
9226   for (i = 0; i < exidx_len; i++)
9227     {
9228       unsigned int exidx_fn, exidx_entry;
9229       struct absaddr fn_addr, entry_addr;
9230       bfd_vma fn;
9231
9232       fputc ('\n', stdout);
9233
9234       if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9235                                      8 * i, & exidx_fn, & fn_addr, NULL)
9236           || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9237                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
9238         {
9239           free (aux->funtab);
9240           arm_free_section (& exidx_arm_sec);
9241           arm_free_section (& extab_arm_sec);
9242           return FALSE;
9243         }
9244
9245       /* ARM EHABI, Section 5:
9246          An index table entry consists of 2 words.
9247          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
9248       if (exidx_fn & 0x80000000)
9249         {
9250           warn (_("corrupt index table entry: %x\n"), exidx_fn);
9251           res = FALSE;
9252         }
9253
9254       fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9255
9256       arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9257       fputs (": ", stdout);
9258
9259       if (exidx_entry == 1)
9260         {
9261           print_vma (exidx_entry, PREFIX_HEX);
9262           fputs (" [cantunwind]\n", stdout);
9263         }
9264       else if (exidx_entry & 0x80000000)
9265         {
9266           print_vma (exidx_entry, PREFIX_HEX);
9267           fputc ('\n', stdout);
9268           decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9269         }
9270       else
9271         {
9272           bfd_vma table, table_offset = 0;
9273           Elf_Internal_Shdr *table_sec;
9274
9275           fputs ("@", stdout);
9276           table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9277           print_vma (table, PREFIX_HEX);
9278           printf ("\n");
9279
9280           /* Locate the matching .ARM.extab.  */
9281           if (entry_addr.section != SHN_UNDEF
9282               && entry_addr.section < filedata->file_header.e_shnum)
9283             {
9284               table_sec = filedata->section_headers + entry_addr.section;
9285               table_offset = entry_addr.offset;
9286               /* PR 18879 */
9287               if (table_offset > table_sec->sh_size
9288                   || ((bfd_signed_vma) table_offset) < 0)
9289                 {
9290                   warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9291                         (unsigned long) table_offset,
9292                         printable_section_name (filedata, table_sec));
9293                   res = FALSE;
9294                   continue;
9295                 }
9296             }
9297           else
9298             {
9299               table_sec = find_section_by_address (filedata, table);
9300               if (table_sec != NULL)
9301                 table_offset = table - table_sec->sh_addr;
9302             }
9303
9304           if (table_sec == NULL)
9305             {
9306               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9307                     (unsigned long) table);
9308               res = FALSE;
9309               continue;
9310             }
9311
9312           if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9313                                    &extab_arm_sec))
9314             res = FALSE;
9315         }
9316     }
9317
9318   printf ("\n");
9319
9320   free (aux->funtab);
9321   arm_free_section (&exidx_arm_sec);
9322   arm_free_section (&extab_arm_sec);
9323
9324   return res;
9325 }
9326
9327 /* Used for both ARM and C6X unwinding tables.  */
9328
9329 static bfd_boolean
9330 arm_process_unwind (Filedata * filedata)
9331 {
9332   struct arm_unw_aux_info aux;
9333   Elf_Internal_Shdr *unwsec = NULL;
9334   Elf_Internal_Shdr *strsec;
9335   Elf_Internal_Shdr *sec;
9336   unsigned long i;
9337   unsigned int sec_type;
9338   bfd_boolean res = TRUE;
9339
9340   switch (filedata->file_header.e_machine)
9341     {
9342     case EM_ARM:
9343       sec_type = SHT_ARM_EXIDX;
9344       break;
9345
9346     case EM_TI_C6000:
9347       sec_type = SHT_C6000_UNWIND;
9348       break;
9349
9350     default:
9351       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9352              filedata->file_header.e_machine);
9353       return FALSE;
9354     }
9355
9356   if (filedata->string_table == NULL)
9357     return FALSE;
9358
9359   memset (& aux, 0, sizeof (aux));
9360   aux.filedata = filedata;
9361
9362   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9363     {
9364       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < filedata->file_header.e_shnum)
9365         {
9366           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
9367
9368           strsec = filedata->section_headers + sec->sh_link;
9369
9370           /* PR binutils/17531 file: 011-12666-0.004.  */
9371           if (aux.strtab != NULL)
9372             {
9373               error (_("Multiple string tables found in file.\n"));
9374               free (aux.strtab);
9375               res = FALSE;
9376             }
9377           aux.strtab = get_data (NULL, filedata, strsec->sh_offset,
9378                                  1, strsec->sh_size, _("string table"));
9379           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9380         }
9381       else if (sec->sh_type == sec_type)
9382         unwsec = sec;
9383     }
9384
9385   if (unwsec == NULL)
9386     printf (_("\nThere are no unwind sections in this file.\n"));
9387   else
9388     for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9389       {
9390         if (sec->sh_type == sec_type)
9391           {
9392             unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9393             printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9394                               "contains %lu entry:\n",
9395                               "\nUnwind section '%s' at offset 0x%lx "
9396                               "contains %lu entries:\n",
9397                               num_unwind),
9398                     printable_section_name (filedata, sec),
9399                     (unsigned long) sec->sh_offset,
9400                     num_unwind);
9401
9402             if (! dump_arm_unwind (filedata, &aux, sec))
9403               res = FALSE;
9404           }
9405       }
9406
9407   if (aux.symtab)
9408     free (aux.symtab);
9409   if (aux.strtab)
9410     free ((char *) aux.strtab);
9411
9412   return res;
9413 }
9414
9415 static bfd_boolean
9416 process_unwind (Filedata * filedata)
9417 {
9418   struct unwind_handler
9419   {
9420     unsigned int machtype;
9421     bfd_boolean (* handler)(Filedata *);
9422   } handlers[] =
9423   {
9424     { EM_ARM, arm_process_unwind },
9425     { EM_IA_64, ia64_process_unwind },
9426     { EM_PARISC, hppa_process_unwind },
9427     { EM_TI_C6000, arm_process_unwind },
9428     { 0, NULL }
9429   };
9430   int i;
9431
9432   if (!do_unwind)
9433     return TRUE;
9434
9435   for (i = 0; handlers[i].handler != NULL; i++)
9436     if (filedata->file_header.e_machine == handlers[i].machtype)
9437       return handlers[i].handler (filedata);
9438
9439   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9440           get_machine_name (filedata->file_header.e_machine));
9441   return TRUE;
9442 }
9443
9444 static void
9445 dynamic_section_aarch64_val (Elf_Internal_Dyn * entry)
9446 {
9447   switch (entry->d_tag)
9448     {
9449     case DT_AARCH64_BTI_PLT:
9450     case DT_AARCH64_PAC_PLT:
9451       break;
9452     default:
9453       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9454       break;
9455     }
9456   putchar ('\n');
9457 }
9458
9459 static void
9460 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9461 {
9462   switch (entry->d_tag)
9463     {
9464     case DT_MIPS_FLAGS:
9465       if (entry->d_un.d_val == 0)
9466         printf (_("NONE"));
9467       else
9468         {
9469           static const char * opts[] =
9470           {
9471             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9472             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9473             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9474             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9475             "RLD_ORDER_SAFE"
9476           };
9477           unsigned int cnt;
9478           bfd_boolean first = TRUE;
9479
9480           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9481             if (entry->d_un.d_val & (1 << cnt))
9482               {
9483                 printf ("%s%s", first ? "" : " ", opts[cnt]);
9484                 first = FALSE;
9485               }
9486         }
9487       break;
9488
9489     case DT_MIPS_IVERSION:
9490       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9491         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9492       else
9493         {
9494           char buf[40];
9495           sprintf_vma (buf, entry->d_un.d_ptr);
9496           /* Note: coded this way so that there is a single string for translation.  */
9497           printf (_("<corrupt: %s>"), buf);
9498         }
9499       break;
9500
9501     case DT_MIPS_TIME_STAMP:
9502       {
9503         char timebuf[128];
9504         struct tm * tmp;
9505         time_t atime = entry->d_un.d_val;
9506
9507         tmp = gmtime (&atime);
9508         /* PR 17531: file: 6accc532.  */
9509         if (tmp == NULL)
9510           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9511         else
9512           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9513                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9514                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9515         printf (_("Time Stamp: %s"), timebuf);
9516       }
9517       break;
9518
9519     case DT_MIPS_RLD_VERSION:
9520     case DT_MIPS_LOCAL_GOTNO:
9521     case DT_MIPS_CONFLICTNO:
9522     case DT_MIPS_LIBLISTNO:
9523     case DT_MIPS_SYMTABNO:
9524     case DT_MIPS_UNREFEXTNO:
9525     case DT_MIPS_HIPAGENO:
9526     case DT_MIPS_DELTA_CLASS_NO:
9527     case DT_MIPS_DELTA_INSTANCE_NO:
9528     case DT_MIPS_DELTA_RELOC_NO:
9529     case DT_MIPS_DELTA_SYM_NO:
9530     case DT_MIPS_DELTA_CLASSSYM_NO:
9531     case DT_MIPS_COMPACT_SIZE:
9532       print_vma (entry->d_un.d_val, DEC);
9533       break;
9534
9535     case DT_MIPS_XHASH:
9536       dynamic_info_DT_MIPS_XHASH = entry->d_un.d_val;
9537       dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9538       /* Falls through.  */
9539
9540     default:
9541       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9542     }
9543     putchar ('\n');
9544 }
9545
9546 static void
9547 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9548 {
9549   switch (entry->d_tag)
9550     {
9551     case DT_HP_DLD_FLAGS:
9552       {
9553         static struct
9554         {
9555           long int bit;
9556           const char * str;
9557         }
9558         flags[] =
9559         {
9560           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9561           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9562           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9563           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9564           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9565           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9566           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9567           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9568           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9569           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9570           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9571           { DT_HP_GST, "HP_GST" },
9572           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9573           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9574           { DT_HP_NODELETE, "HP_NODELETE" },
9575           { DT_HP_GROUP, "HP_GROUP" },
9576           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9577         };
9578         bfd_boolean first = TRUE;
9579         size_t cnt;
9580         bfd_vma val = entry->d_un.d_val;
9581
9582         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9583           if (val & flags[cnt].bit)
9584             {
9585               if (! first)
9586                 putchar (' ');
9587               fputs (flags[cnt].str, stdout);
9588               first = FALSE;
9589               val ^= flags[cnt].bit;
9590             }
9591
9592         if (val != 0 || first)
9593           {
9594             if (! first)
9595               putchar (' ');
9596             print_vma (val, HEX);
9597           }
9598       }
9599       break;
9600
9601     default:
9602       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9603       break;
9604     }
9605   putchar ('\n');
9606 }
9607
9608 #ifdef BFD64
9609
9610 /* VMS vs Unix time offset and factor.  */
9611
9612 #define VMS_EPOCH_OFFSET 35067168000000000LL
9613 #define VMS_GRANULARITY_FACTOR 10000000
9614
9615 /* Display a VMS time in a human readable format.  */
9616
9617 static void
9618 print_vms_time (bfd_int64_t vmstime)
9619 {
9620   struct tm *tm;
9621   time_t unxtime;
9622
9623   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9624   tm = gmtime (&unxtime);
9625   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9626           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9627           tm->tm_hour, tm->tm_min, tm->tm_sec);
9628 }
9629 #endif /* BFD64 */
9630
9631 static void
9632 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9633 {
9634   switch (entry->d_tag)
9635     {
9636     case DT_IA_64_PLT_RESERVE:
9637       /* First 3 slots reserved.  */
9638       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9639       printf (" -- ");
9640       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9641       break;
9642
9643     case DT_IA_64_VMS_LINKTIME:
9644 #ifdef BFD64
9645       print_vms_time (entry->d_un.d_val);
9646 #endif
9647       break;
9648
9649     case DT_IA_64_VMS_LNKFLAGS:
9650       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9651       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9652         printf (" CALL_DEBUG");
9653       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9654         printf (" NOP0BUFS");
9655       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9656         printf (" P0IMAGE");
9657       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9658         printf (" MKTHREADS");
9659       if (entry->d_un.d_val & VMS_LF_UPCALLS)
9660         printf (" UPCALLS");
9661       if (entry->d_un.d_val & VMS_LF_IMGSTA)
9662         printf (" IMGSTA");
9663       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9664         printf (" INITIALIZE");
9665       if (entry->d_un.d_val & VMS_LF_MAIN)
9666         printf (" MAIN");
9667       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9668         printf (" EXE_INIT");
9669       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9670         printf (" TBK_IN_IMG");
9671       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9672         printf (" DBG_IN_IMG");
9673       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9674         printf (" TBK_IN_DSF");
9675       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9676         printf (" DBG_IN_DSF");
9677       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9678         printf (" SIGNATURES");
9679       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9680         printf (" REL_SEG_OFF");
9681       break;
9682
9683     default:
9684       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9685       break;
9686     }
9687   putchar ('\n');
9688 }
9689
9690 static bfd_boolean
9691 get_32bit_dynamic_section (Filedata * filedata)
9692 {
9693   Elf32_External_Dyn * edyn;
9694   Elf32_External_Dyn * ext;
9695   Elf_Internal_Dyn * entry;
9696
9697   edyn = (Elf32_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9698                                           dynamic_size, _("dynamic section"));
9699   if (!edyn)
9700     return FALSE;
9701
9702   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9703      might not have the luxury of section headers.  Look for the DT_NULL
9704      terminator to determine the number of entries.  */
9705   for (ext = edyn, dynamic_nent = 0;
9706        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9707        ext++)
9708     {
9709       dynamic_nent++;
9710       if (BYTE_GET (ext->d_tag) == DT_NULL)
9711         break;
9712     }
9713
9714   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9715                                                   sizeof (* entry));
9716   if (dynamic_section == NULL)
9717     {
9718       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9719              (unsigned long) dynamic_nent);
9720       free (edyn);
9721       return FALSE;
9722     }
9723
9724   for (ext = edyn, entry = dynamic_section;
9725        entry < dynamic_section + dynamic_nent;
9726        ext++, entry++)
9727     {
9728       entry->d_tag      = BYTE_GET (ext->d_tag);
9729       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9730     }
9731
9732   free (edyn);
9733
9734   return TRUE;
9735 }
9736
9737 static bfd_boolean
9738 get_64bit_dynamic_section (Filedata * filedata)
9739 {
9740   Elf64_External_Dyn * edyn;
9741   Elf64_External_Dyn * ext;
9742   Elf_Internal_Dyn * entry;
9743
9744   /* Read in the data.  */
9745   edyn = (Elf64_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9746                                           dynamic_size, _("dynamic section"));
9747   if (!edyn)
9748     return FALSE;
9749
9750   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9751      might not have the luxury of section headers.  Look for the DT_NULL
9752      terminator to determine the number of entries.  */
9753   for (ext = edyn, dynamic_nent = 0;
9754        /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer.  */
9755        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9756        ext++)
9757     {
9758       dynamic_nent++;
9759       if (BYTE_GET (ext->d_tag) == DT_NULL)
9760         break;
9761     }
9762
9763   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9764                                                   sizeof (* entry));
9765   if (dynamic_section == NULL)
9766     {
9767       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9768              (unsigned long) dynamic_nent);
9769       free (edyn);
9770       return FALSE;
9771     }
9772
9773   /* Convert from external to internal formats.  */
9774   for (ext = edyn, entry = dynamic_section;
9775        entry < dynamic_section + dynamic_nent;
9776        ext++, entry++)
9777     {
9778       entry->d_tag      = BYTE_GET (ext->d_tag);
9779       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9780     }
9781
9782   free (edyn);
9783
9784   return TRUE;
9785 }
9786
9787 static void
9788 print_dynamic_flags (bfd_vma flags)
9789 {
9790   bfd_boolean first = TRUE;
9791
9792   while (flags)
9793     {
9794       bfd_vma flag;
9795
9796       flag = flags & - flags;
9797       flags &= ~ flag;
9798
9799       if (first)
9800         first = FALSE;
9801       else
9802         putc (' ', stdout);
9803
9804       switch (flag)
9805         {
9806         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
9807         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
9808         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
9809         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
9810         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
9811         default:                fputs (_("unknown"), stdout); break;
9812         }
9813     }
9814   puts ("");
9815 }
9816
9817 /* Parse and display the contents of the dynamic section.  */
9818
9819 static bfd_boolean
9820 process_dynamic_section (Filedata * filedata)
9821 {
9822   Elf_Internal_Dyn * entry;
9823
9824   if (dynamic_size == 0)
9825     {
9826       if (do_dynamic)
9827         printf (_("\nThere is no dynamic section in this file.\n"));
9828
9829       return TRUE;
9830     }
9831
9832   if (is_32bit_elf)
9833     {
9834       if (! get_32bit_dynamic_section (filedata))
9835         return FALSE;
9836     }
9837   else
9838     {
9839       if (! get_64bit_dynamic_section (filedata))
9840         return FALSE;
9841     }
9842
9843   /* Find the appropriate symbol table.  */
9844   if (dynamic_symbols == NULL)
9845     {
9846       for (entry = dynamic_section;
9847            entry < dynamic_section + dynamic_nent;
9848            ++entry)
9849         {
9850           Elf_Internal_Shdr section;
9851
9852           if (entry->d_tag != DT_SYMTAB)
9853             continue;
9854
9855           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9856
9857           /* Since we do not know how big the symbol table is,
9858              we default to reading in the entire file (!) and
9859              processing that.  This is overkill, I know, but it
9860              should work.  */
9861           section.sh_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9862           if ((bfd_size_type) section.sh_offset > filedata->file_size)
9863             {
9864               /* See PR 21379 for a reproducer.  */
9865               error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9866               return FALSE;
9867             }
9868
9869           if (archive_file_offset != 0)
9870             section.sh_size = archive_file_size - section.sh_offset;
9871           else
9872             section.sh_size = filedata->file_size - section.sh_offset;
9873
9874           if (is_32bit_elf)
9875             section.sh_entsize = sizeof (Elf32_External_Sym);
9876           else
9877             section.sh_entsize = sizeof (Elf64_External_Sym);
9878           section.sh_name = filedata->string_table_length;
9879
9880           if (dynamic_symbols != NULL)
9881             {
9882               error (_("Multiple dynamic symbol table sections found\n"));
9883               free (dynamic_symbols);
9884             }
9885           dynamic_symbols = GET_ELF_SYMBOLS (filedata, &section, & num_dynamic_syms);
9886           if (num_dynamic_syms < 1)
9887             {
9888               error (_("Unable to determine the number of symbols to load\n"));
9889               continue;
9890             }
9891         }
9892     }
9893
9894   /* Similarly find a string table.  */
9895   if (dynamic_strings == NULL)
9896     {
9897       for (entry = dynamic_section;
9898            entry < dynamic_section + dynamic_nent;
9899            ++entry)
9900         {
9901           unsigned long offset;
9902           long str_tab_len;
9903
9904           if (entry->d_tag != DT_STRTAB)
9905             continue;
9906
9907           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9908
9909           /* Since we do not know how big the string table is,
9910              we default to reading in the entire file (!) and
9911              processing that.  This is overkill, I know, but it
9912              should work.  */
9913
9914           offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9915
9916           if (archive_file_offset != 0)
9917             str_tab_len = archive_file_size - offset;
9918           else
9919             str_tab_len = filedata->file_size - offset;
9920
9921           if (str_tab_len < 1)
9922             {
9923               error
9924                 (_("Unable to determine the length of the dynamic string table\n"));
9925               continue;
9926             }
9927
9928           if (dynamic_strings != NULL)
9929             {
9930               error (_("Multiple dynamic string tables found\n"));
9931               free (dynamic_strings);
9932             }
9933
9934           dynamic_strings = (char *) get_data (NULL, filedata, offset, 1,
9935                                                str_tab_len,
9936                                                _("dynamic string table"));
9937           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9938         }
9939     }
9940
9941   /* And find the syminfo section if available.  */
9942   if (dynamic_syminfo == NULL)
9943     {
9944       unsigned long syminsz = 0;
9945
9946       for (entry = dynamic_section;
9947            entry < dynamic_section + dynamic_nent;
9948            ++entry)
9949         {
9950           if (entry->d_tag == DT_SYMINENT)
9951             {
9952               /* Note: these braces are necessary to avoid a syntax
9953                  error from the SunOS4 C compiler.  */
9954               /* PR binutils/17531: A corrupt file can trigger this test.
9955                  So do not use an assert, instead generate an error message.  */
9956               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9957                 error (_("Bad value (%d) for SYMINENT entry\n"),
9958                        (int) entry->d_un.d_val);
9959             }
9960           else if (entry->d_tag == DT_SYMINSZ)
9961             syminsz = entry->d_un.d_val;
9962           else if (entry->d_tag == DT_SYMINFO)
9963             dynamic_syminfo_offset = offset_from_vma (filedata, entry->d_un.d_val,
9964                                                       syminsz);
9965         }
9966
9967       if (dynamic_syminfo_offset != 0 && syminsz != 0)
9968         {
9969           Elf_External_Syminfo * extsyminfo;
9970           Elf_External_Syminfo * extsym;
9971           Elf_Internal_Syminfo * syminfo;
9972
9973           /* There is a syminfo section.  Read the data.  */
9974           extsyminfo = (Elf_External_Syminfo *)
9975               get_data (NULL, filedata, dynamic_syminfo_offset, 1, syminsz,
9976                         _("symbol information"));
9977           if (!extsyminfo)
9978             return FALSE;
9979
9980           if (dynamic_syminfo != NULL)
9981             {
9982               error (_("Multiple dynamic symbol information sections found\n"));
9983               free (dynamic_syminfo);
9984             }
9985           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9986           if (dynamic_syminfo == NULL)
9987             {
9988               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9989                      (unsigned long) syminsz);
9990               return FALSE;
9991             }
9992
9993           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9994           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9995                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9996                ++syminfo, ++extsym)
9997             {
9998               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9999               syminfo->si_flags = BYTE_GET (extsym->si_flags);
10000             }
10001
10002           free (extsyminfo);
10003         }
10004     }
10005
10006   if (do_dynamic && dynamic_addr)
10007     printf (ngettext ("\nDynamic section at offset 0x%lx "
10008                       "contains %lu entry:\n",
10009                       "\nDynamic section at offset 0x%lx "
10010                       "contains %lu entries:\n",
10011                       dynamic_nent),
10012             dynamic_addr, (unsigned long) dynamic_nent);
10013   if (do_dynamic)
10014     printf (_("  Tag        Type                         Name/Value\n"));
10015
10016   for (entry = dynamic_section;
10017        entry < dynamic_section + dynamic_nent;
10018        entry++)
10019     {
10020       if (do_dynamic)
10021         {
10022           const char * dtype;
10023
10024           putchar (' ');
10025           print_vma (entry->d_tag, FULL_HEX);
10026           dtype = get_dynamic_type (filedata, entry->d_tag);
10027           printf (" (%s)%*s", dtype,
10028                   ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
10029         }
10030
10031       switch (entry->d_tag)
10032         {
10033         case DT_FLAGS:
10034           if (do_dynamic)
10035             print_dynamic_flags (entry->d_un.d_val);
10036           break;
10037
10038         case DT_AUXILIARY:
10039         case DT_FILTER:
10040         case DT_CONFIG:
10041         case DT_DEPAUDIT:
10042         case DT_AUDIT:
10043           if (do_dynamic)
10044             {
10045               switch (entry->d_tag)
10046                 {
10047                 case DT_AUXILIARY:
10048                   printf (_("Auxiliary library"));
10049                   break;
10050
10051                 case DT_FILTER:
10052                   printf (_("Filter library"));
10053                   break;
10054
10055                 case DT_CONFIG:
10056                   printf (_("Configuration file"));
10057                   break;
10058
10059                 case DT_DEPAUDIT:
10060                   printf (_("Dependency audit library"));
10061                   break;
10062
10063                 case DT_AUDIT:
10064                   printf (_("Audit library"));
10065                   break;
10066                 }
10067
10068               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10069                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
10070               else
10071                 {
10072                   printf (": ");
10073                   print_vma (entry->d_un.d_val, PREFIX_HEX);
10074                   putchar ('\n');
10075                 }
10076             }
10077           break;
10078
10079         case DT_FEATURE:
10080           if (do_dynamic)
10081             {
10082               printf (_("Flags:"));
10083
10084               if (entry->d_un.d_val == 0)
10085                 printf (_(" None\n"));
10086               else
10087                 {
10088                   unsigned long int val = entry->d_un.d_val;
10089
10090                   if (val & DTF_1_PARINIT)
10091                     {
10092                       printf (" PARINIT");
10093                       val ^= DTF_1_PARINIT;
10094                     }
10095                   if (val & DTF_1_CONFEXP)
10096                     {
10097                       printf (" CONFEXP");
10098                       val ^= DTF_1_CONFEXP;
10099                     }
10100                   if (val != 0)
10101                     printf (" %lx", val);
10102                   puts ("");
10103                 }
10104             }
10105           break;
10106
10107         case DT_POSFLAG_1:
10108           if (do_dynamic)
10109             {
10110               printf (_("Flags:"));
10111
10112               if (entry->d_un.d_val == 0)
10113                 printf (_(" None\n"));
10114               else
10115                 {
10116                   unsigned long int val = entry->d_un.d_val;
10117
10118                   if (val & DF_P1_LAZYLOAD)
10119                     {
10120                       printf (" LAZYLOAD");
10121                       val ^= DF_P1_LAZYLOAD;
10122                     }
10123                   if (val & DF_P1_GROUPPERM)
10124                     {
10125                       printf (" GROUPPERM");
10126                       val ^= DF_P1_GROUPPERM;
10127                     }
10128                   if (val != 0)
10129                     printf (" %lx", val);
10130                   puts ("");
10131                 }
10132             }
10133           break;
10134
10135         case DT_FLAGS_1:
10136           if (do_dynamic)
10137             {
10138               printf (_("Flags:"));
10139               if (entry->d_un.d_val == 0)
10140                 printf (_(" None\n"));
10141               else
10142                 {
10143                   unsigned long int val = entry->d_un.d_val;
10144
10145                   if (val & DF_1_NOW)
10146                     {
10147                       printf (" NOW");
10148                       val ^= DF_1_NOW;
10149                     }
10150                   if (val & DF_1_GLOBAL)
10151                     {
10152                       printf (" GLOBAL");
10153                       val ^= DF_1_GLOBAL;
10154                     }
10155                   if (val & DF_1_GROUP)
10156                     {
10157                       printf (" GROUP");
10158                       val ^= DF_1_GROUP;
10159                     }
10160                   if (val & DF_1_NODELETE)
10161                     {
10162                       printf (" NODELETE");
10163                       val ^= DF_1_NODELETE;
10164                     }
10165                   if (val & DF_1_LOADFLTR)
10166                     {
10167                       printf (" LOADFLTR");
10168                       val ^= DF_1_LOADFLTR;
10169                     }
10170                   if (val & DF_1_INITFIRST)
10171                     {
10172                       printf (" INITFIRST");
10173                       val ^= DF_1_INITFIRST;
10174                     }
10175                   if (val & DF_1_NOOPEN)
10176                     {
10177                       printf (" NOOPEN");
10178                       val ^= DF_1_NOOPEN;
10179                     }
10180                   if (val & DF_1_ORIGIN)
10181                     {
10182                       printf (" ORIGIN");
10183                       val ^= DF_1_ORIGIN;
10184                     }
10185                   if (val & DF_1_DIRECT)
10186                     {
10187                       printf (" DIRECT");
10188                       val ^= DF_1_DIRECT;
10189                     }
10190                   if (val & DF_1_TRANS)
10191                     {
10192                       printf (" TRANS");
10193                       val ^= DF_1_TRANS;
10194                     }
10195                   if (val & DF_1_INTERPOSE)
10196                     {
10197                       printf (" INTERPOSE");
10198                       val ^= DF_1_INTERPOSE;
10199                     }
10200                   if (val & DF_1_NODEFLIB)
10201                     {
10202                       printf (" NODEFLIB");
10203                       val ^= DF_1_NODEFLIB;
10204                     }
10205                   if (val & DF_1_NODUMP)
10206                     {
10207                       printf (" NODUMP");
10208                       val ^= DF_1_NODUMP;
10209                     }
10210                   if (val & DF_1_CONFALT)
10211                     {
10212                       printf (" CONFALT");
10213                       val ^= DF_1_CONFALT;
10214                     }
10215                   if (val & DF_1_ENDFILTEE)
10216                     {
10217                       printf (" ENDFILTEE");
10218                       val ^= DF_1_ENDFILTEE;
10219                     }
10220                   if (val & DF_1_DISPRELDNE)
10221                     {
10222                       printf (" DISPRELDNE");
10223                       val ^= DF_1_DISPRELDNE;
10224                     }
10225                   if (val & DF_1_DISPRELPND)
10226                     {
10227                       printf (" DISPRELPND");
10228                       val ^= DF_1_DISPRELPND;
10229                     }
10230                   if (val & DF_1_NODIRECT)
10231                     {
10232                       printf (" NODIRECT");
10233                       val ^= DF_1_NODIRECT;
10234                     }
10235                   if (val & DF_1_IGNMULDEF)
10236                     {
10237                       printf (" IGNMULDEF");
10238                       val ^= DF_1_IGNMULDEF;
10239                     }
10240                   if (val & DF_1_NOKSYMS)
10241                     {
10242                       printf (" NOKSYMS");
10243                       val ^= DF_1_NOKSYMS;
10244                     }
10245                   if (val & DF_1_NOHDR)
10246                     {
10247                       printf (" NOHDR");
10248                       val ^= DF_1_NOHDR;
10249                     }
10250                   if (val & DF_1_EDITED)
10251                     {
10252                       printf (" EDITED");
10253                       val ^= DF_1_EDITED;
10254                     }
10255                   if (val & DF_1_NORELOC)
10256                     {
10257                       printf (" NORELOC");
10258                       val ^= DF_1_NORELOC;
10259                     }
10260                   if (val & DF_1_SYMINTPOSE)
10261                     {
10262                       printf (" SYMINTPOSE");
10263                       val ^= DF_1_SYMINTPOSE;
10264                     }
10265                   if (val & DF_1_GLOBAUDIT)
10266                     {
10267                       printf (" GLOBAUDIT");
10268                       val ^= DF_1_GLOBAUDIT;
10269                     }
10270                   if (val & DF_1_SINGLETON)
10271                     {
10272                       printf (" SINGLETON");
10273                       val ^= DF_1_SINGLETON;
10274                     }
10275                   if (val & DF_1_STUB)
10276                     {
10277                       printf (" STUB");
10278                       val ^= DF_1_STUB;
10279                     }
10280                   if (val & DF_1_PIE)
10281                     {
10282                       printf (" PIE");
10283                       val ^= DF_1_PIE;
10284                     }
10285                   if (val & DF_1_KMOD)
10286                     {
10287                       printf (" KMOD");
10288                       val ^= DF_1_KMOD;
10289                     }
10290                   if (val & DF_1_WEAKFILTER)
10291                     {
10292                       printf (" WEAKFILTER");
10293                       val ^= DF_1_WEAKFILTER;
10294                     }
10295                   if (val & DF_1_NOCOMMON)
10296                     {
10297                       printf (" NOCOMMON");
10298                       val ^= DF_1_NOCOMMON;
10299                     }
10300                   if (val != 0)
10301                     printf (" %lx", val);
10302                   puts ("");
10303                 }
10304             }
10305           break;
10306
10307         case DT_PLTREL:
10308           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10309           if (do_dynamic)
10310             puts (get_dynamic_type (filedata, entry->d_un.d_val));
10311           break;
10312
10313         case DT_NULL    :
10314         case DT_NEEDED  :
10315         case DT_PLTGOT  :
10316         case DT_HASH    :
10317         case DT_STRTAB  :
10318         case DT_SYMTAB  :
10319         case DT_RELA    :
10320         case DT_INIT    :
10321         case DT_FINI    :
10322         case DT_SONAME  :
10323         case DT_RPATH   :
10324         case DT_SYMBOLIC:
10325         case DT_REL     :
10326         case DT_DEBUG   :
10327         case DT_TEXTREL :
10328         case DT_JMPREL  :
10329         case DT_RUNPATH :
10330           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10331
10332           if (do_dynamic)
10333             {
10334               char * name;
10335
10336               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10337                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10338               else
10339                 name = NULL;
10340
10341               if (name)
10342                 {
10343                   switch (entry->d_tag)
10344                     {
10345                     case DT_NEEDED:
10346                       printf (_("Shared library: [%s]"), name);
10347
10348                       if (streq (name, program_interpreter))
10349                         printf (_(" program interpreter"));
10350                       break;
10351
10352                     case DT_SONAME:
10353                       printf (_("Library soname: [%s]"), name);
10354                       break;
10355
10356                     case DT_RPATH:
10357                       printf (_("Library rpath: [%s]"), name);
10358                       break;
10359
10360                     case DT_RUNPATH:
10361                       printf (_("Library runpath: [%s]"), name);
10362                       break;
10363
10364                     default:
10365                       print_vma (entry->d_un.d_val, PREFIX_HEX);
10366                       break;
10367                     }
10368                 }
10369               else
10370                 print_vma (entry->d_un.d_val, PREFIX_HEX);
10371
10372               putchar ('\n');
10373             }
10374           break;
10375
10376         case DT_PLTRELSZ:
10377         case DT_RELASZ  :
10378         case DT_STRSZ   :
10379         case DT_RELSZ   :
10380         case DT_RELAENT :
10381         case DT_SYMENT  :
10382         case DT_RELENT  :
10383           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10384           /* Fall through.  */
10385         case DT_PLTPADSZ:
10386         case DT_MOVEENT :
10387         case DT_MOVESZ  :
10388         case DT_INIT_ARRAYSZ:
10389         case DT_FINI_ARRAYSZ:
10390         case DT_GNU_CONFLICTSZ:
10391         case DT_GNU_LIBLISTSZ:
10392           if (do_dynamic)
10393             {
10394               print_vma (entry->d_un.d_val, UNSIGNED);
10395               printf (_(" (bytes)\n"));
10396             }
10397           break;
10398
10399         case DT_VERDEFNUM:
10400         case DT_VERNEEDNUM:
10401         case DT_RELACOUNT:
10402         case DT_RELCOUNT:
10403           if (do_dynamic)
10404             {
10405               print_vma (entry->d_un.d_val, UNSIGNED);
10406               putchar ('\n');
10407             }
10408           break;
10409
10410         case DT_SYMINSZ:
10411         case DT_SYMINENT:
10412         case DT_SYMINFO:
10413         case DT_USED:
10414         case DT_INIT_ARRAY:
10415         case DT_FINI_ARRAY:
10416           if (do_dynamic)
10417             {
10418               if (entry->d_tag == DT_USED
10419                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10420                 {
10421                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10422
10423                   if (*name)
10424                     {
10425                       printf (_("Not needed object: [%s]\n"), name);
10426                       break;
10427                     }
10428                 }
10429
10430               print_vma (entry->d_un.d_val, PREFIX_HEX);
10431               putchar ('\n');
10432             }
10433           break;
10434
10435         case DT_BIND_NOW:
10436           /* The value of this entry is ignored.  */
10437           if (do_dynamic)
10438             putchar ('\n');
10439           break;
10440
10441         case DT_GNU_PRELINKED:
10442           if (do_dynamic)
10443             {
10444               struct tm * tmp;
10445               time_t atime = entry->d_un.d_val;
10446
10447               tmp = gmtime (&atime);
10448               /* PR 17533 file: 041-1244816-0.004.  */
10449               if (tmp == NULL)
10450                 printf (_("<corrupt time val: %lx"),
10451                         (unsigned long) atime);
10452               else
10453                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10454                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10455                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10456
10457             }
10458           break;
10459
10460         case DT_GNU_HASH:
10461           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10462           if (do_dynamic)
10463             {
10464               print_vma (entry->d_un.d_val, PREFIX_HEX);
10465               putchar ('\n');
10466             }
10467           break;
10468
10469         default:
10470           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10471             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10472               entry->d_un.d_val;
10473
10474           if (do_dynamic)
10475             {
10476               switch (filedata->file_header.e_machine)
10477                 {
10478                 case EM_AARCH64:
10479                   dynamic_section_aarch64_val (entry);
10480                   break;
10481                 case EM_MIPS:
10482                 case EM_MIPS_RS3_LE:
10483                   dynamic_section_mips_val (entry);
10484                   break;
10485                 case EM_PARISC:
10486                   dynamic_section_parisc_val (entry);
10487                   break;
10488                 case EM_IA_64:
10489                   dynamic_section_ia64_val (entry);
10490                   break;
10491                 default:
10492                   print_vma (entry->d_un.d_val, PREFIX_HEX);
10493                   putchar ('\n');
10494                 }
10495             }
10496           break;
10497         }
10498     }
10499
10500   return TRUE;
10501 }
10502
10503 static char *
10504 get_ver_flags (unsigned int flags)
10505 {
10506   static char buff[128];
10507
10508   buff[0] = 0;
10509
10510   if (flags == 0)
10511     return _("none");
10512
10513   if (flags & VER_FLG_BASE)
10514     strcat (buff, "BASE");
10515
10516   if (flags & VER_FLG_WEAK)
10517     {
10518       if (flags & VER_FLG_BASE)
10519         strcat (buff, " | ");
10520
10521       strcat (buff, "WEAK");
10522     }
10523
10524   if (flags & VER_FLG_INFO)
10525     {
10526       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10527         strcat (buff, " | ");
10528
10529       strcat (buff, "INFO");
10530     }
10531
10532   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10533     {
10534       if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10535         strcat (buff, " | ");
10536
10537       strcat (buff, _("<unknown>"));
10538     }
10539
10540   return buff;
10541 }
10542
10543 /* Display the contents of the version sections.  */
10544
10545 static bfd_boolean
10546 process_version_sections (Filedata * filedata)
10547 {
10548   Elf_Internal_Shdr * section;
10549   unsigned i;
10550   bfd_boolean found = FALSE;
10551
10552   if (! do_version)
10553     return TRUE;
10554
10555   for (i = 0, section = filedata->section_headers;
10556        i < filedata->file_header.e_shnum;
10557        i++, section++)
10558     {
10559       switch (section->sh_type)
10560         {
10561         case SHT_GNU_verdef:
10562           {
10563             Elf_External_Verdef * edefs;
10564             unsigned long idx;
10565             unsigned long cnt;
10566             char * endbuf;
10567
10568             found = TRUE;
10569
10570             printf (ngettext ("\nVersion definition section '%s' "
10571                               "contains %u entry:\n",
10572                               "\nVersion definition section '%s' "
10573                               "contains %u entries:\n",
10574                               section->sh_info),
10575                     printable_section_name (filedata, section),
10576                     section->sh_info);
10577
10578             printf (_(" Addr: 0x"));
10579             printf_vma (section->sh_addr);
10580             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10581                     (unsigned long) section->sh_offset, section->sh_link,
10582                     printable_section_name_from_index (filedata, section->sh_link));
10583
10584             edefs = (Elf_External_Verdef *)
10585                 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
10586                           _("version definition section"));
10587             if (!edefs)
10588               break;
10589             endbuf = (char *) edefs + section->sh_size;
10590
10591             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10592               {
10593                 char * vstart;
10594                 Elf_External_Verdef * edef;
10595                 Elf_Internal_Verdef ent;
10596                 Elf_External_Verdaux * eaux;
10597                 Elf_Internal_Verdaux aux;
10598                 unsigned long isum;
10599                 int j;
10600
10601                 vstart = ((char *) edefs) + idx;
10602                 if (vstart + sizeof (*edef) > endbuf)
10603                   break;
10604
10605                 edef = (Elf_External_Verdef *) vstart;
10606
10607                 ent.vd_version = BYTE_GET (edef->vd_version);
10608                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
10609                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
10610                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
10611                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
10612                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
10613                 ent.vd_next    = BYTE_GET (edef->vd_next);
10614
10615                 printf (_("  %#06lx: Rev: %d  Flags: %s"),
10616                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10617
10618                 printf (_("  Index: %d  Cnt: %d  "),
10619                         ent.vd_ndx, ent.vd_cnt);
10620
10621                 /* Check for overflow.  */
10622                 if (ent.vd_aux > (size_t) (endbuf - vstart))
10623                   break;
10624
10625                 vstart += ent.vd_aux;
10626
10627                 if (vstart + sizeof (*eaux) > endbuf)
10628                   break;
10629                 eaux = (Elf_External_Verdaux *) vstart;
10630
10631                 aux.vda_name = BYTE_GET (eaux->vda_name);
10632                 aux.vda_next = BYTE_GET (eaux->vda_next);
10633
10634                 if (VALID_DYNAMIC_NAME (aux.vda_name))
10635                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10636                 else
10637                   printf (_("Name index: %ld\n"), aux.vda_name);
10638
10639                 isum = idx + ent.vd_aux;
10640
10641                 for (j = 1; j < ent.vd_cnt; j++)
10642                   {
10643                     if (aux.vda_next < sizeof (*eaux)
10644                         && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10645                       {
10646                         warn (_("Invalid vda_next field of %lx\n"),
10647                               aux.vda_next);
10648                         j = ent.vd_cnt;
10649                         break;
10650                       }
10651                     /* Check for overflow.  */
10652                     if (aux.vda_next > (size_t) (endbuf - vstart))
10653                       break;
10654
10655                     isum   += aux.vda_next;
10656                     vstart += aux.vda_next;
10657
10658                     if (vstart + sizeof (*eaux) > endbuf)
10659                       break;
10660                     eaux = (Elf_External_Verdaux *) vstart;
10661
10662                     aux.vda_name = BYTE_GET (eaux->vda_name);
10663                     aux.vda_next = BYTE_GET (eaux->vda_next);
10664
10665                     if (VALID_DYNAMIC_NAME (aux.vda_name))
10666                       printf (_("  %#06lx: Parent %d: %s\n"),
10667                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10668                     else
10669                       printf (_("  %#06lx: Parent %d, name index: %ld\n"),
10670                               isum, j, aux.vda_name);
10671                   }
10672
10673                 if (j < ent.vd_cnt)
10674                   printf (_("  Version def aux past end of section\n"));
10675
10676                 /* PR 17531:
10677                    file: id:000001,src:000172+005151,op:splice,rep:2.  */
10678                 if (ent.vd_next < sizeof (*edef)
10679                     && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10680                   {
10681                     warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10682                     cnt = section->sh_info;
10683                     break;
10684                   }
10685                 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10686                   break;
10687
10688                 idx += ent.vd_next;
10689               }
10690
10691             if (cnt < section->sh_info)
10692               printf (_("  Version definition past end of section\n"));
10693
10694             free (edefs);
10695           }
10696           break;
10697
10698         case SHT_GNU_verneed:
10699           {
10700             Elf_External_Verneed * eneed;
10701             unsigned long idx;
10702             unsigned long cnt;
10703             char * endbuf;
10704
10705             found = TRUE;
10706
10707             printf (ngettext ("\nVersion needs section '%s' "
10708                               "contains %u entry:\n",
10709                               "\nVersion needs section '%s' "
10710                               "contains %u entries:\n",
10711                               section->sh_info),
10712                     printable_section_name (filedata, section), section->sh_info);
10713
10714             printf (_(" Addr: 0x"));
10715             printf_vma (section->sh_addr);
10716             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10717                     (unsigned long) section->sh_offset, section->sh_link,
10718                     printable_section_name_from_index (filedata, section->sh_link));
10719
10720             eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
10721                                                        section->sh_offset, 1,
10722                                                        section->sh_size,
10723                                                        _("Version Needs section"));
10724             if (!eneed)
10725               break;
10726             endbuf = (char *) eneed + section->sh_size;
10727
10728             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10729               {
10730                 Elf_External_Verneed * entry;
10731                 Elf_Internal_Verneed ent;
10732                 unsigned long isum;
10733                 int j;
10734                 char * vstart;
10735
10736                 vstart = ((char *) eneed) + idx;
10737                 if (vstart + sizeof (*entry) > endbuf)
10738                   break;
10739
10740                 entry = (Elf_External_Verneed *) vstart;
10741
10742                 ent.vn_version = BYTE_GET (entry->vn_version);
10743                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
10744                 ent.vn_file    = BYTE_GET (entry->vn_file);
10745                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
10746                 ent.vn_next    = BYTE_GET (entry->vn_next);
10747
10748                 printf (_("  %#06lx: Version: %d"), idx, ent.vn_version);
10749
10750                 if (VALID_DYNAMIC_NAME (ent.vn_file))
10751                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10752                 else
10753                   printf (_("  File: %lx"), ent.vn_file);
10754
10755                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
10756
10757                 /* Check for overflow.  */
10758                 if (ent.vn_aux > (size_t) (endbuf - vstart))
10759                   break;
10760                 vstart += ent.vn_aux;
10761
10762                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10763                   {
10764                     Elf_External_Vernaux * eaux;
10765                     Elf_Internal_Vernaux aux;
10766
10767                     if (vstart + sizeof (*eaux) > endbuf)
10768                       break;
10769                     eaux = (Elf_External_Vernaux *) vstart;
10770
10771                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
10772                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
10773                     aux.vna_other = BYTE_GET (eaux->vna_other);
10774                     aux.vna_name  = BYTE_GET (eaux->vna_name);
10775                     aux.vna_next  = BYTE_GET (eaux->vna_next);
10776
10777                     if (VALID_DYNAMIC_NAME (aux.vna_name))
10778                       printf (_("  %#06lx:   Name: %s"),
10779                               isum, GET_DYNAMIC_NAME (aux.vna_name));
10780                     else
10781                       printf (_("  %#06lx:   Name index: %lx"),
10782                               isum, aux.vna_name);
10783
10784                     printf (_("  Flags: %s  Version: %d\n"),
10785                             get_ver_flags (aux.vna_flags), aux.vna_other);
10786
10787                     if (aux.vna_next < sizeof (*eaux)
10788                         && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10789                       {
10790                         warn (_("Invalid vna_next field of %lx\n"),
10791                               aux.vna_next);
10792                         j = ent.vn_cnt;
10793                         break;
10794                       }
10795                     /* Check for overflow.  */
10796                     if (aux.vna_next > (size_t) (endbuf - vstart))
10797                       break;
10798                     isum   += aux.vna_next;
10799                     vstart += aux.vna_next;
10800                   }
10801
10802                 if (j < ent.vn_cnt)
10803                   warn (_("Missing Version Needs auxillary information\n"));
10804
10805                 if (ent.vn_next < sizeof (*entry)
10806                     && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10807                   {
10808                     warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10809                     cnt = section->sh_info;
10810                     break;
10811                   }
10812                 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10813                   break;
10814                 idx += ent.vn_next;
10815               }
10816
10817             if (cnt < section->sh_info)
10818               warn (_("Missing Version Needs information\n"));
10819
10820             free (eneed);
10821           }
10822           break;
10823
10824         case SHT_GNU_versym:
10825           {
10826             Elf_Internal_Shdr * link_section;
10827             size_t total;
10828             unsigned int cnt;
10829             unsigned char * edata;
10830             unsigned short * data;
10831             char * strtab;
10832             Elf_Internal_Sym * symbols;
10833             Elf_Internal_Shdr * string_sec;
10834             unsigned long num_syms;
10835             long off;
10836
10837             if (section->sh_link >= filedata->file_header.e_shnum)
10838               break;
10839
10840             link_section = filedata->section_headers + section->sh_link;
10841             total = section->sh_size / sizeof (Elf_External_Versym);
10842
10843             if (link_section->sh_link >= filedata->file_header.e_shnum)
10844               break;
10845
10846             found = TRUE;
10847
10848             symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
10849             if (symbols == NULL)
10850               break;
10851
10852             string_sec = filedata->section_headers + link_section->sh_link;
10853
10854             strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
10855                                         string_sec->sh_size,
10856                                         _("version string table"));
10857             if (!strtab)
10858               {
10859                 free (symbols);
10860                 break;
10861               }
10862
10863             printf (ngettext ("\nVersion symbols section '%s' "
10864                               "contains %lu entry:\n",
10865                               "\nVersion symbols section '%s' "
10866                               "contains %lu entries:\n",
10867                               total),
10868                     printable_section_name (filedata, section), (unsigned long) total);
10869
10870             printf (_(" Addr: 0x"));
10871             printf_vma (section->sh_addr);
10872             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10873                     (unsigned long) section->sh_offset, section->sh_link,
10874                     printable_section_name (filedata, link_section));
10875
10876             off = offset_from_vma (filedata,
10877                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10878                                    total * sizeof (short));
10879             edata = (unsigned char *) get_data (NULL, filedata, off, total,
10880                                                 sizeof (short),
10881                                                 _("version symbol data"));
10882             if (!edata)
10883               {
10884                 free (strtab);
10885                 free (symbols);
10886                 break;
10887               }
10888
10889             data = (short unsigned int *) cmalloc (total, sizeof (short));
10890
10891             for (cnt = total; cnt --;)
10892               data[cnt] = byte_get (edata + cnt * sizeof (short),
10893                                     sizeof (short));
10894
10895             free (edata);
10896
10897             for (cnt = 0; cnt < total; cnt += 4)
10898               {
10899                 int j, nn;
10900                 char *name;
10901                 char *invalid = _("*invalid*");
10902
10903                 printf ("  %03x:", cnt);
10904
10905                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10906                   switch (data[cnt + j])
10907                     {
10908                     case 0:
10909                       fputs (_("   0 (*local*)    "), stdout);
10910                       break;
10911
10912                     case 1:
10913                       fputs (_("   1 (*global*)   "), stdout);
10914                       break;
10915
10916                     default:
10917                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10918                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10919
10920                       /* If this index value is greater than the size of the symbols
10921                          array, break to avoid an out-of-bounds read.  */
10922                       if ((unsigned long)(cnt + j) >= num_syms)
10923                         {
10924                           warn (_("invalid index into symbol array\n"));
10925                           break;
10926                         }
10927
10928                       name = NULL;
10929                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10930                         {
10931                           Elf_Internal_Verneed ivn;
10932                           unsigned long offset;
10933
10934                           offset = offset_from_vma
10935                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10936                              sizeof (Elf_External_Verneed));
10937
10938                           do
10939                             {
10940                               Elf_Internal_Vernaux ivna;
10941                               Elf_External_Verneed evn;
10942                               Elf_External_Vernaux evna;
10943                               unsigned long a_off;
10944
10945                               if (get_data (&evn, filedata, offset, sizeof (evn), 1,
10946                                             _("version need")) == NULL)
10947                                 break;
10948
10949                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10950                               ivn.vn_next = BYTE_GET (evn.vn_next);
10951
10952                               a_off = offset + ivn.vn_aux;
10953
10954                               do
10955                                 {
10956                                   if (get_data (&evna, filedata, a_off, sizeof (evna),
10957                                                 1, _("version need aux (2)")) == NULL)
10958                                     {
10959                                       ivna.vna_next  = 0;
10960                                       ivna.vna_other = 0;
10961                                     }
10962                                   else
10963                                     {
10964                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
10965                                       ivna.vna_other = BYTE_GET (evna.vna_other);
10966                                     }
10967
10968                                   a_off += ivna.vna_next;
10969                                 }
10970                               while (ivna.vna_other != data[cnt + j]
10971                                      && ivna.vna_next != 0);
10972
10973                               if (ivna.vna_other == data[cnt + j])
10974                                 {
10975                                   ivna.vna_name = BYTE_GET (evna.vna_name);
10976
10977                                   if (ivna.vna_name >= string_sec->sh_size)
10978                                     name = invalid;
10979                                   else
10980                                     name = strtab + ivna.vna_name;
10981                                   break;
10982                                 }
10983
10984                               offset += ivn.vn_next;
10985                             }
10986                           while (ivn.vn_next);
10987                         }
10988
10989                       if (data[cnt + j] != 0x8001
10990                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10991                         {
10992                           Elf_Internal_Verdef ivd;
10993                           Elf_External_Verdef evd;
10994                           unsigned long offset;
10995
10996                           offset = offset_from_vma
10997                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10998                              sizeof evd);
10999
11000                           do
11001                             {
11002                               if (get_data (&evd, filedata, offset, sizeof (evd), 1,
11003                                             _("version def")) == NULL)
11004                                 {
11005                                   ivd.vd_next = 0;
11006                                   /* PR 17531: file: 046-1082287-0.004.  */
11007                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
11008                                   break;
11009                                 }
11010                               else
11011                                 {
11012                                   ivd.vd_next = BYTE_GET (evd.vd_next);
11013                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
11014                                 }
11015
11016                               offset += ivd.vd_next;
11017                             }
11018                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
11019                                  && ivd.vd_next != 0);
11020
11021                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
11022                             {
11023                               Elf_External_Verdaux evda;
11024                               Elf_Internal_Verdaux ivda;
11025
11026                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11027
11028                               if (get_data (&evda, filedata,
11029                                             offset - ivd.vd_next + ivd.vd_aux,
11030                                             sizeof (evda), 1,
11031                                             _("version def aux")) == NULL)
11032                                 break;
11033
11034                               ivda.vda_name = BYTE_GET (evda.vda_name);
11035
11036                               if (ivda.vda_name >= string_sec->sh_size)
11037                                 name = invalid;
11038                               else if (name != NULL && name != invalid)
11039                                 name = _("*both*");
11040                               else
11041                                 name = strtab + ivda.vda_name;
11042                             }
11043                         }
11044                       if (name != NULL)
11045                         nn += printf ("(%s%-*s",
11046                                       name,
11047                                       12 - (int) strlen (name),
11048                                       ")");
11049
11050                       if (nn < 18)
11051                         printf ("%*c", 18 - nn, ' ');
11052                     }
11053
11054                 putchar ('\n');
11055               }
11056
11057             free (data);
11058             free (strtab);
11059             free (symbols);
11060           }
11061           break;
11062
11063         default:
11064           break;
11065         }
11066     }
11067
11068   if (! found)
11069     printf (_("\nNo version information found in this file.\n"));
11070
11071   return TRUE;
11072 }
11073
11074 static const char *
11075 get_symbol_binding (Filedata * filedata, unsigned int binding)
11076 {
11077   static char buff[32];
11078
11079   switch (binding)
11080     {
11081     case STB_LOCAL:     return "LOCAL";
11082     case STB_GLOBAL:    return "GLOBAL";
11083     case STB_WEAK:      return "WEAK";
11084     default:
11085       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
11086         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
11087                   binding);
11088       else if (binding >= STB_LOOS && binding <= STB_HIOS)
11089         {
11090           if (binding == STB_GNU_UNIQUE
11091               && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU)
11092             return "UNIQUE";
11093           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
11094         }
11095       else
11096         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
11097       return buff;
11098     }
11099 }
11100
11101 static const char *
11102 get_symbol_type (Filedata * filedata, unsigned int type)
11103 {
11104   static char buff[32];
11105
11106   switch (type)
11107     {
11108     case STT_NOTYPE:    return "NOTYPE";
11109     case STT_OBJECT:    return "OBJECT";
11110     case STT_FUNC:      return "FUNC";
11111     case STT_SECTION:   return "SECTION";
11112     case STT_FILE:      return "FILE";
11113     case STT_COMMON:    return "COMMON";
11114     case STT_TLS:       return "TLS";
11115     case STT_RELC:      return "RELC";
11116     case STT_SRELC:     return "SRELC";
11117     default:
11118       if (type >= STT_LOPROC && type <= STT_HIPROC)
11119         {
11120           if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
11121             return "THUMB_FUNC";
11122
11123           if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
11124             return "REGISTER";
11125
11126           if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
11127             return "PARISC_MILLI";
11128
11129           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
11130         }
11131       else if (type >= STT_LOOS && type <= STT_HIOS)
11132         {
11133           if (filedata->file_header.e_machine == EM_PARISC)
11134             {
11135               if (type == STT_HP_OPAQUE)
11136                 return "HP_OPAQUE";
11137               if (type == STT_HP_STUB)
11138                 return "HP_STUB";
11139             }
11140
11141           if (type == STT_GNU_IFUNC
11142               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
11143                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD))
11144             return "IFUNC";
11145
11146           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
11147         }
11148       else
11149         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
11150       return buff;
11151     }
11152 }
11153
11154 static const char *
11155 get_symbol_visibility (unsigned int visibility)
11156 {
11157   switch (visibility)
11158     {
11159     case STV_DEFAULT:   return "DEFAULT";
11160     case STV_INTERNAL:  return "INTERNAL";
11161     case STV_HIDDEN:    return "HIDDEN";
11162     case STV_PROTECTED: return "PROTECTED";
11163     default:
11164       error (_("Unrecognized visibility value: %u"), visibility);
11165       return _("<unknown>");
11166     }
11167 }
11168
11169 static const char *
11170 get_alpha_symbol_other (unsigned int other)
11171 {
11172   switch (other)
11173     {
11174     case STO_ALPHA_NOPV:       return "NOPV";
11175     case STO_ALPHA_STD_GPLOAD: return "STD GPLOAD";
11176     default:
11177       error (_("Unrecognized alpah specific other value: %u"), other);
11178       return _("<unknown>");
11179     }
11180 }
11181
11182 static const char *
11183 get_solaris_symbol_visibility (unsigned int visibility)
11184 {
11185   switch (visibility)
11186     {
11187     case 4: return "EXPORTED";
11188     case 5: return "SINGLETON";
11189     case 6: return "ELIMINATE";
11190     default: return get_symbol_visibility (visibility);
11191     }
11192 }
11193
11194 static const char *
11195 get_aarch64_symbol_other (unsigned int other)
11196 {
11197   static char buf[32];
11198
11199   if (other & STO_AARCH64_VARIANT_PCS)
11200     {
11201       other &= ~STO_AARCH64_VARIANT_PCS;
11202       if (other == 0)
11203         return "VARIANT_PCS";
11204       snprintf (buf, sizeof buf, "VARIANT_PCS | %x", other);
11205       return buf;
11206     }
11207   return NULL;
11208 }
11209
11210 static const char *
11211 get_mips_symbol_other (unsigned int other)
11212 {
11213   switch (other)
11214     {
11215     case STO_OPTIONAL:      return "OPTIONAL";
11216     case STO_MIPS_PLT:      return "MIPS PLT";
11217     case STO_MIPS_PIC:      return "MIPS PIC";
11218     case STO_MICROMIPS:     return "MICROMIPS";
11219     case STO_MICROMIPS | STO_MIPS_PIC:      return "MICROMIPS, MIPS PIC";
11220     case STO_MIPS16:        return "MIPS16";
11221     default:                return NULL;
11222     }
11223 }
11224
11225 static const char *
11226 get_ia64_symbol_other (Filedata * filedata, unsigned int other)
11227 {
11228   if (is_ia64_vms (filedata))
11229     {
11230       static char res[32];
11231
11232       res[0] = 0;
11233
11234       /* Function types is for images and .STB files only.  */
11235       switch (filedata->file_header.e_type)
11236         {
11237         case ET_DYN:
11238         case ET_EXEC:
11239           switch (VMS_ST_FUNC_TYPE (other))
11240             {
11241             case VMS_SFT_CODE_ADDR:
11242               strcat (res, " CA");
11243               break;
11244             case VMS_SFT_SYMV_IDX:
11245               strcat (res, " VEC");
11246               break;
11247             case VMS_SFT_FD:
11248               strcat (res, " FD");
11249               break;
11250             case VMS_SFT_RESERVE:
11251               strcat (res, " RSV");
11252               break;
11253             default:
11254               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11255                     VMS_ST_FUNC_TYPE (other));
11256               strcat (res, " <unknown>");
11257               break;
11258             }
11259           break;
11260         default:
11261           break;
11262         }
11263       switch (VMS_ST_LINKAGE (other))
11264         {
11265         case VMS_STL_IGNORE:
11266           strcat (res, " IGN");
11267           break;
11268         case VMS_STL_RESERVE:
11269           strcat (res, " RSV");
11270           break;
11271         case VMS_STL_STD:
11272           strcat (res, " STD");
11273           break;
11274         case VMS_STL_LNK:
11275           strcat (res, " LNK");
11276           break;
11277         default:
11278           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11279                 VMS_ST_LINKAGE (other));
11280           strcat (res, " <unknown>");
11281           break;
11282         }
11283
11284       if (res[0] != 0)
11285         return res + 1;
11286       else
11287         return res;
11288     }
11289   return NULL;
11290 }
11291
11292 static const char *
11293 get_ppc64_symbol_other (unsigned int other)
11294 {
11295   if ((other & ~STO_PPC64_LOCAL_MASK) != 0)
11296     return NULL;
11297
11298   other >>= STO_PPC64_LOCAL_BIT;
11299   if (other <= 6)
11300     {
11301       static char buf[32];
11302       if (other >= 2)
11303         other = ppc64_decode_local_entry (other);
11304       snprintf (buf, sizeof buf, _("<localentry>: %d"), other);
11305       return buf;
11306     }
11307   return NULL;
11308 }
11309
11310 static const char *
11311 get_symbol_other (Filedata * filedata, unsigned int other)
11312 {
11313   const char * result = NULL;
11314   static char buff [32];
11315
11316   if (other == 0)
11317     return "";
11318
11319   switch (filedata->file_header.e_machine)
11320     {
11321     case EM_ALPHA:
11322       result = get_alpha_symbol_other (other);
11323       break;
11324     case EM_AARCH64:
11325       result = get_aarch64_symbol_other (other);
11326       break;
11327     case EM_MIPS:
11328       result = get_mips_symbol_other (other);
11329       break;
11330     case EM_IA_64:
11331       result = get_ia64_symbol_other (filedata, other);
11332       break;
11333     case EM_PPC64:
11334       result = get_ppc64_symbol_other (other);
11335       break;
11336     default:
11337       result = NULL;
11338       break;
11339     }
11340
11341   if (result)
11342     return result;
11343
11344   snprintf (buff, sizeof buff, _("<other>: %x"), other);
11345   return buff;
11346 }
11347
11348 static const char *
11349 get_symbol_index_type (Filedata * filedata, unsigned int type)
11350 {
11351   static char buff[32];
11352
11353   switch (type)
11354     {
11355     case SHN_UNDEF:     return "UND";
11356     case SHN_ABS:       return "ABS";
11357     case SHN_COMMON:    return "COM";
11358     default:
11359       if (type == SHN_IA_64_ANSI_COMMON
11360           && filedata->file_header.e_machine == EM_IA_64
11361           && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11362         return "ANSI_COM";
11363       else if ((filedata->file_header.e_machine == EM_X86_64
11364                 || filedata->file_header.e_machine == EM_L1OM
11365                 || filedata->file_header.e_machine == EM_K1OM)
11366                && type == SHN_X86_64_LCOMMON)
11367         return "LARGE_COM";
11368       else if ((type == SHN_MIPS_SCOMMON
11369                 && filedata->file_header.e_machine == EM_MIPS)
11370                || (type == SHN_TIC6X_SCOMMON
11371                    && filedata->file_header.e_machine == EM_TI_C6000))
11372         return "SCOM";
11373       else if (type == SHN_MIPS_SUNDEFINED
11374                && filedata->file_header.e_machine == EM_MIPS)
11375         return "SUND";
11376       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11377         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11378       else if (type >= SHN_LOOS && type <= SHN_HIOS)
11379         sprintf (buff, "OS [0x%04x]", type & 0xffff);
11380       else if (type >= SHN_LORESERVE)
11381         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11382       else if (type >= filedata->file_header.e_shnum)
11383         sprintf (buff, _("bad section index[%3d]"), type);
11384       else
11385         sprintf (buff, "%3d", type);
11386       break;
11387     }
11388
11389   return buff;
11390 }
11391
11392 static bfd_vma *
11393 get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
11394 {
11395   unsigned char * e_data;
11396   bfd_vma * i_data;
11397
11398   /* If the size_t type is smaller than the bfd_size_type, eg because
11399      you are building a 32-bit tool on a 64-bit host, then make sure
11400      that when (number) is cast to (size_t) no information is lost.  */
11401   if (sizeof (size_t) < sizeof (bfd_size_type)
11402       && (bfd_size_type) ((size_t) number) != number)
11403     {
11404       error (_("Size truncation prevents reading %s elements of size %u\n"),
11405              bfd_vmatoa ("u", number), ent_size);
11406       return NULL;
11407     }
11408
11409   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11410      attempting to allocate memory when the read is bound to fail.  */
11411   if (ent_size * number > filedata->file_size)
11412     {
11413       error (_("Invalid number of dynamic entries: %s\n"),
11414              bfd_vmatoa ("u", number));
11415       return NULL;
11416     }
11417
11418   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11419   if (e_data == NULL)
11420     {
11421       error (_("Out of memory reading %s dynamic entries\n"),
11422              bfd_vmatoa ("u", number));
11423       return NULL;
11424     }
11425
11426   if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
11427     {
11428       error (_("Unable to read in %s bytes of dynamic data\n"),
11429              bfd_vmatoa ("u", number * ent_size));
11430       free (e_data);
11431       return NULL;
11432     }
11433
11434   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11435   if (i_data == NULL)
11436     {
11437       error (_("Out of memory allocating space for %s dynamic entries\n"),
11438              bfd_vmatoa ("u", number));
11439       free (e_data);
11440       return NULL;
11441     }
11442
11443   while (number--)
11444     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11445
11446   free (e_data);
11447
11448   return i_data;
11449 }
11450
11451 static void
11452 print_dynamic_symbol (Filedata * filedata, bfd_vma si, unsigned long hn)
11453 {
11454   Elf_Internal_Sym * psym;
11455   int n;
11456
11457   n = print_vma (si, DEC_5);
11458   if (n < 5)
11459     fputs (&"     "[n], stdout);
11460   printf (" %3lu: ", hn);
11461
11462   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11463     {
11464       printf (_("<No info available for dynamic symbol number %lu>\n"),
11465               (unsigned long) si);
11466       return;
11467     }
11468
11469   psym = dynamic_symbols + si;
11470   print_vma (psym->st_value, LONG_HEX);
11471   putchar (' ');
11472   print_vma (psym->st_size, DEC_5);
11473
11474   printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11475   printf (" %-6s",  get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11476
11477   if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11478     printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11479   else
11480     {
11481       unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11482
11483       printf (" %-7s",  get_symbol_visibility (vis));
11484       /* Check to see if any other bits in the st_other field are set.
11485          Note - displaying this information disrupts the layout of the
11486          table being generated, but for the moment this case is very
11487          rare.  */
11488       if (psym->st_other ^ vis)
11489         printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11490     }
11491
11492   printf (" %3.3s ", get_symbol_index_type (filedata, psym->st_shndx));
11493   if (VALID_DYNAMIC_NAME (psym->st_name))
11494     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11495   else
11496     printf (_(" <corrupt: %14ld>"), psym->st_name);
11497   putchar ('\n');
11498 }
11499
11500 static const char *
11501 get_symbol_version_string (Filedata *                   filedata,
11502                            bfd_boolean                  is_dynsym,
11503                            const char *                 strtab,
11504                            unsigned long int            strtab_size,
11505                            unsigned int                 si,
11506                            Elf_Internal_Sym *           psym,
11507                            enum versioned_symbol_info * sym_info,
11508                            unsigned short *             vna_other)
11509 {
11510   unsigned char data[2];
11511   unsigned short vers_data;
11512   unsigned long offset;
11513   unsigned short max_vd_ndx;
11514
11515   if (!is_dynsym
11516       || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11517     return NULL;
11518
11519   offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11520                             sizeof data + si * sizeof (vers_data));
11521
11522   if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11523                 sizeof (data), 1, _("version data")) == NULL)
11524     return NULL;
11525
11526   vers_data = byte_get (data, 2);
11527
11528   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data == 0)
11529     return NULL;
11530
11531   *sym_info = (vers_data & VERSYM_HIDDEN) != 0 ? symbol_hidden : symbol_public;
11532   max_vd_ndx = 0;
11533
11534   /* Usually we'd only see verdef for defined symbols, and verneed for
11535      undefined symbols.  However, symbols defined by the linker in
11536      .dynbss for variables copied from a shared library in order to
11537      avoid text relocations are defined yet have verneed.  We could
11538      use a heuristic to detect the special case, for example, check
11539      for verneed first on symbols defined in SHT_NOBITS sections, but
11540      it is simpler and more reliable to just look for both verdef and
11541      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
11542
11543   if (psym->st_shndx != SHN_UNDEF
11544       && vers_data != 0x8001
11545       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11546     {
11547       Elf_Internal_Verdef ivd;
11548       Elf_Internal_Verdaux ivda;
11549       Elf_External_Verdaux evda;
11550       unsigned long off;
11551
11552       off = offset_from_vma (filedata,
11553                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11554                              sizeof (Elf_External_Verdef));
11555
11556       do
11557         {
11558           Elf_External_Verdef evd;
11559
11560           if (get_data (&evd, filedata, off, sizeof (evd), 1,
11561                         _("version def")) == NULL)
11562             {
11563               ivd.vd_ndx = 0;
11564               ivd.vd_aux = 0;
11565               ivd.vd_next = 0;
11566               ivd.vd_flags = 0;
11567             }
11568           else
11569             {
11570               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11571               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11572               ivd.vd_next = BYTE_GET (evd.vd_next);
11573               ivd.vd_flags = BYTE_GET (evd.vd_flags);
11574             }
11575
11576           if ((ivd.vd_ndx & VERSYM_VERSION) > max_vd_ndx)
11577             max_vd_ndx = ivd.vd_ndx & VERSYM_VERSION;
11578
11579           off += ivd.vd_next;
11580         }
11581       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11582
11583       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11584         {
11585           if (ivd.vd_ndx == 1 && ivd.vd_flags == VER_FLG_BASE)
11586             return NULL;
11587
11588           off -= ivd.vd_next;
11589           off += ivd.vd_aux;
11590
11591           if (get_data (&evda, filedata, off, sizeof (evda), 1,
11592                         _("version def aux")) != NULL)
11593             {
11594               ivda.vda_name = BYTE_GET (evda.vda_name);
11595
11596               if (psym->st_name != ivda.vda_name)
11597                 return (ivda.vda_name < strtab_size
11598                         ? strtab + ivda.vda_name : _("<corrupt>"));
11599             }
11600         }
11601     }
11602
11603   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11604     {
11605       Elf_External_Verneed evn;
11606       Elf_Internal_Verneed ivn;
11607       Elf_Internal_Vernaux ivna;
11608
11609       offset = offset_from_vma (filedata,
11610                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11611                                 sizeof evn);
11612       do
11613         {
11614           unsigned long vna_off;
11615
11616           if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11617                         _("version need")) == NULL)
11618             {
11619               ivna.vna_next = 0;
11620               ivna.vna_other = 0;
11621               ivna.vna_name = 0;
11622               break;
11623             }
11624
11625           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
11626           ivn.vn_next = BYTE_GET (evn.vn_next);
11627
11628           vna_off = offset + ivn.vn_aux;
11629
11630           do
11631             {
11632               Elf_External_Vernaux evna;
11633
11634               if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11635                             _("version need aux (3)")) == NULL)
11636                 {
11637                   ivna.vna_next = 0;
11638                   ivna.vna_other = 0;
11639                   ivna.vna_name = 0;
11640                 }
11641               else
11642                 {
11643                   ivna.vna_other = BYTE_GET (evna.vna_other);
11644                   ivna.vna_next  = BYTE_GET (evna.vna_next);
11645                   ivna.vna_name  = BYTE_GET (evna.vna_name);
11646                 }
11647
11648               vna_off += ivna.vna_next;
11649             }
11650           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11651
11652           if (ivna.vna_other == vers_data)
11653             break;
11654
11655           offset += ivn.vn_next;
11656         }
11657       while (ivn.vn_next != 0);
11658
11659       if (ivna.vna_other == vers_data)
11660         {
11661           *sym_info = symbol_undefined;
11662           *vna_other = ivna.vna_other;
11663           return (ivna.vna_name < strtab_size
11664                   ? strtab + ivna.vna_name : _("<corrupt>"));
11665         }
11666       else if ((max_vd_ndx || (vers_data & VERSYM_VERSION) != 1)
11667                && (vers_data & VERSYM_VERSION) > max_vd_ndx)
11668         return _("<corrupt>");
11669     }
11670   return NULL;
11671 }
11672
11673 /* Dump the symbol table.  */
11674 static bfd_boolean
11675 process_symbol_table (Filedata * filedata)
11676 {
11677   Elf_Internal_Shdr * section;
11678   bfd_size_type nbuckets = 0;
11679   bfd_size_type nchains = 0;
11680   bfd_vma * buckets = NULL;
11681   bfd_vma * chains = NULL;
11682   bfd_vma ngnubuckets = 0;
11683   bfd_vma * gnubuckets = NULL;
11684   bfd_vma * gnuchains = NULL;
11685   bfd_vma * mipsxlat = NULL;
11686   bfd_vma gnusymidx = 0;
11687   bfd_size_type ngnuchains = 0;
11688
11689   if (!do_syms && !do_dyn_syms && !do_histogram)
11690     return TRUE;
11691
11692   if (dynamic_info[DT_HASH]
11693       && (do_histogram
11694           || (do_using_dynamic
11695               && !do_dyn_syms
11696               && dynamic_strings != NULL)))
11697     {
11698       unsigned char nb[8];
11699       unsigned char nc[8];
11700       unsigned int hash_ent_size = 4;
11701
11702       if ((filedata->file_header.e_machine == EM_ALPHA
11703            || filedata->file_header.e_machine == EM_S390
11704            || filedata->file_header.e_machine == EM_S390_OLD)
11705           && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11706         hash_ent_size = 8;
11707
11708       if (fseek (filedata->handle,
11709                  (archive_file_offset
11710                   + offset_from_vma (filedata, dynamic_info[DT_HASH],
11711                                      sizeof nb + sizeof nc)),
11712                  SEEK_SET))
11713         {
11714           error (_("Unable to seek to start of dynamic information\n"));
11715           goto no_hash;
11716         }
11717
11718       if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11719         {
11720           error (_("Failed to read in number of buckets\n"));
11721           goto no_hash;
11722         }
11723
11724       if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11725         {
11726           error (_("Failed to read in number of chains\n"));
11727           goto no_hash;
11728         }
11729
11730       nbuckets = byte_get (nb, hash_ent_size);
11731       nchains  = byte_get (nc, hash_ent_size);
11732
11733       buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11734       chains  = get_dynamic_data (filedata, nchains, hash_ent_size);
11735
11736     no_hash:
11737       if (buckets == NULL || chains == NULL)
11738         {
11739           if (do_using_dynamic)
11740             return FALSE;
11741           free (buckets);
11742           free (chains);
11743           buckets = NULL;
11744           chains = NULL;
11745           nbuckets = 0;
11746           nchains = 0;
11747         }
11748     }
11749
11750   if (dynamic_info_DT_GNU_HASH
11751       && (do_histogram
11752           || (do_using_dynamic
11753               && !do_dyn_syms
11754               && dynamic_strings != NULL)))
11755     {
11756       unsigned char nb[16];
11757       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11758       bfd_vma buckets_vma;
11759
11760       if (fseek (filedata->handle,
11761                  (archive_file_offset
11762                   + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11763                                      sizeof nb)),
11764                  SEEK_SET))
11765         {
11766           error (_("Unable to seek to start of dynamic information\n"));
11767           goto no_gnu_hash;
11768         }
11769
11770       if (fread (nb, 16, 1, filedata->handle) != 1)
11771         {
11772           error (_("Failed to read in number of buckets\n"));
11773           goto no_gnu_hash;
11774         }
11775
11776       ngnubuckets = byte_get (nb, 4);
11777       gnusymidx = byte_get (nb + 4, 4);
11778       bitmaskwords = byte_get (nb + 8, 4);
11779       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11780       if (is_32bit_elf)
11781         buckets_vma += bitmaskwords * 4;
11782       else
11783         buckets_vma += bitmaskwords * 8;
11784
11785       if (fseek (filedata->handle,
11786                  (archive_file_offset
11787                   + offset_from_vma (filedata, buckets_vma, 4)),
11788                  SEEK_SET))
11789         {
11790           error (_("Unable to seek to start of dynamic information\n"));
11791           goto no_gnu_hash;
11792         }
11793
11794       gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11795
11796       if (gnubuckets == NULL)
11797         goto no_gnu_hash;
11798
11799       for (i = 0; i < ngnubuckets; i++)
11800         if (gnubuckets[i] != 0)
11801           {
11802             if (gnubuckets[i] < gnusymidx)
11803               return FALSE;
11804
11805             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11806               maxchain = gnubuckets[i];
11807           }
11808
11809       if (maxchain == 0xffffffff)
11810         goto no_gnu_hash;
11811
11812       maxchain -= gnusymidx;
11813
11814       if (fseek (filedata->handle,
11815                  (archive_file_offset
11816                   + offset_from_vma (filedata, buckets_vma
11817                                            + 4 * (ngnubuckets + maxchain), 4)),
11818                  SEEK_SET))
11819         {
11820           error (_("Unable to seek to start of dynamic information\n"));
11821           goto no_gnu_hash;
11822         }
11823
11824       do
11825         {
11826           if (fread (nb, 4, 1, filedata->handle) != 1)
11827             {
11828               error (_("Failed to determine last chain length\n"));
11829               goto no_gnu_hash;
11830             }
11831
11832           if (maxchain + 1 == 0)
11833             goto no_gnu_hash;
11834
11835           ++maxchain;
11836         }
11837       while ((byte_get (nb, 4) & 1) == 0);
11838
11839       if (fseek (filedata->handle,
11840                  (archive_file_offset
11841                   + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11842                  SEEK_SET))
11843         {
11844           error (_("Unable to seek to start of dynamic information\n"));
11845           goto no_gnu_hash;
11846         }
11847
11848       gnuchains = get_dynamic_data (filedata, maxchain, 4);
11849       ngnuchains = maxchain;
11850
11851       if (gnuchains == NULL)
11852         goto no_gnu_hash;
11853
11854       if (dynamic_info_DT_MIPS_XHASH)
11855         {
11856           if (fseek (filedata->handle,
11857                      (archive_file_offset
11858                       + offset_from_vma (filedata, (buckets_vma
11859                                                     + 4 * (ngnubuckets
11860                                                            + maxchain)), 4)),
11861                      SEEK_SET))
11862             {
11863               error (_("Unable to seek to start of dynamic information\n"));
11864               goto no_gnu_hash;
11865             }
11866
11867           mipsxlat = get_dynamic_data (filedata, maxchain, 4);
11868         }
11869
11870     no_gnu_hash:
11871       if (dynamic_info_DT_MIPS_XHASH && mipsxlat == NULL)
11872         {
11873           free (gnuchains);
11874           gnuchains = NULL;
11875         }
11876       if (gnuchains == NULL)
11877         {
11878           free (gnubuckets);
11879           gnubuckets = NULL;
11880           ngnubuckets = 0;
11881           if (do_using_dynamic)
11882             return FALSE;
11883         }
11884     }
11885
11886   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11887       && do_syms
11888       && do_using_dynamic
11889       && dynamic_strings != NULL
11890       && dynamic_symbols != NULL)
11891     {
11892       unsigned long hn;
11893
11894       if (dynamic_info[DT_HASH])
11895         {
11896           bfd_vma si;
11897           char *visited;
11898
11899           printf (_("\nSymbol table for image:\n"));
11900           if (is_32bit_elf)
11901             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11902           else
11903             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11904
11905           visited = xcmalloc (nchains, 1);
11906           memset (visited, 0, nchains);
11907           for (hn = 0; hn < nbuckets; hn++)
11908             {
11909               for (si = buckets[hn]; si > 0; si = chains[si])
11910                 {
11911                   print_dynamic_symbol (filedata, si, hn);
11912                   if (si >= nchains || visited[si])
11913                     {
11914                       error (_("histogram chain is corrupt\n"));
11915                       break;
11916                     }
11917                   visited[si] = 1;
11918                 }
11919             }
11920           free (visited);
11921         }
11922
11923       if (dynamic_info_DT_GNU_HASH)
11924         {
11925           printf (_("\nSymbol table of `%s' for image:\n"),
11926                   GNU_HASH_SECTION_NAME);
11927           if (is_32bit_elf)
11928             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11929           else
11930             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11931
11932           for (hn = 0; hn < ngnubuckets; ++hn)
11933             if (gnubuckets[hn] != 0)
11934               {
11935                 bfd_vma si = gnubuckets[hn];
11936                 bfd_vma off = si - gnusymidx;
11937
11938                 do
11939                   {
11940                     if (dynamic_info_DT_MIPS_XHASH)
11941                       print_dynamic_symbol (filedata, mipsxlat[off], hn);
11942                     else
11943                       print_dynamic_symbol (filedata, si, hn);
11944                     si++;
11945                   }
11946                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11947               }
11948         }
11949     }
11950   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11951            && filedata->section_headers != NULL)
11952     {
11953       unsigned int i;
11954
11955       for (i = 0, section = filedata->section_headers;
11956            i < filedata->file_header.e_shnum;
11957            i++, section++)
11958         {
11959           unsigned int si;
11960           char * strtab = NULL;
11961           unsigned long int strtab_size = 0;
11962           Elf_Internal_Sym * symtab;
11963           Elf_Internal_Sym * psym;
11964           unsigned long num_syms;
11965
11966           if ((section->sh_type != SHT_SYMTAB
11967                && section->sh_type != SHT_DYNSYM)
11968               || (!do_syms
11969                   && section->sh_type == SHT_SYMTAB))
11970             continue;
11971
11972           if (section->sh_entsize == 0)
11973             {
11974               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11975                       printable_section_name (filedata, section));
11976               continue;
11977             }
11978
11979           num_syms = section->sh_size / section->sh_entsize;
11980           printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11981                             "\nSymbol table '%s' contains %lu entries:\n",
11982                             num_syms),
11983                   printable_section_name (filedata, section),
11984                   num_syms);
11985
11986           if (is_32bit_elf)
11987             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
11988           else
11989             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
11990
11991           symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
11992           if (symtab == NULL)
11993             continue;
11994
11995           if (section->sh_link == filedata->file_header.e_shstrndx)
11996             {
11997               strtab = filedata->string_table;
11998               strtab_size = filedata->string_table_length;
11999             }
12000           else if (section->sh_link < filedata->file_header.e_shnum)
12001             {
12002               Elf_Internal_Shdr * string_sec;
12003
12004               string_sec = filedata->section_headers + section->sh_link;
12005
12006               strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
12007                                           1, string_sec->sh_size,
12008                                           _("string table"));
12009               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
12010             }
12011
12012           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
12013             {
12014               const char *version_string;
12015               enum versioned_symbol_info sym_info;
12016               unsigned short vna_other;
12017
12018               printf ("%6d: ", si);
12019               print_vma (psym->st_value, LONG_HEX);
12020               putchar (' ');
12021               print_vma (psym->st_size, DEC_5);
12022               printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
12023               printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
12024               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
12025                 printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
12026               else
12027                 {
12028                   unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
12029
12030                   printf (" %-7s", get_symbol_visibility (vis));
12031                   /* Check to see if any other bits in the st_other field are set.
12032                      Note - displaying this information disrupts the layout of the
12033                      table being generated, but for the moment this case is very rare.  */
12034                   if (psym->st_other ^ vis)
12035                     printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
12036                 }
12037               printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
12038               print_symbol (25, psym->st_name < strtab_size
12039                             ? strtab + psym->st_name : _("<corrupt>"));
12040
12041               version_string
12042                 = get_symbol_version_string (filedata,
12043                                              section->sh_type == SHT_DYNSYM,
12044                                              strtab, strtab_size, si,
12045                                              psym, &sym_info, &vna_other);
12046               if (version_string)
12047                 {
12048                   if (sym_info == symbol_undefined)
12049                     printf ("@%s (%d)", version_string, vna_other);
12050                   else
12051                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
12052                             version_string);
12053                 }
12054
12055               putchar ('\n');
12056
12057               if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
12058                   && si >= section->sh_info
12059                   /* Irix 5 and 6 MIPS binaries are known to ignore this requirement.  */
12060                   && filedata->file_header.e_machine != EM_MIPS
12061                   /* Solaris binaries have been found to violate this requirement as
12062                      well.  Not sure if this is a bug or an ABI requirement.  */
12063                   && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
12064                 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
12065                       si, printable_section_name (filedata, section), section->sh_info);
12066             }
12067
12068           free (symtab);
12069           if (strtab != filedata->string_table)
12070             free (strtab);
12071         }
12072     }
12073   else if (do_syms)
12074     printf
12075       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12076
12077   if (do_histogram && buckets != NULL)
12078     {
12079       unsigned long * lengths;
12080       unsigned long * counts;
12081       unsigned long hn;
12082       bfd_vma si;
12083       unsigned long maxlength = 0;
12084       unsigned long nzero_counts = 0;
12085       unsigned long nsyms = 0;
12086       char *visited;
12087
12088       printf (ngettext ("\nHistogram for bucket list length "
12089                         "(total of %lu bucket):\n",
12090                         "\nHistogram for bucket list length "
12091                         "(total of %lu buckets):\n",
12092                         (unsigned long) nbuckets),
12093               (unsigned long) nbuckets);
12094
12095       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
12096       if (lengths == NULL)
12097         {
12098           error (_("Out of memory allocating space for histogram buckets\n"));
12099           return FALSE;
12100         }
12101       visited = xcmalloc (nchains, 1);
12102       memset (visited, 0, nchains);
12103
12104       printf (_(" Length  Number     %% of total  Coverage\n"));
12105       for (hn = 0; hn < nbuckets; ++hn)
12106         {
12107           for (si = buckets[hn]; si > 0; si = chains[si])
12108             {
12109               ++nsyms;
12110               if (maxlength < ++lengths[hn])
12111                 ++maxlength;
12112               if (si >= nchains || visited[si])
12113                 {
12114                   error (_("histogram chain is corrupt\n"));
12115                   break;
12116                 }
12117               visited[si] = 1;
12118             }
12119         }
12120       free (visited);
12121
12122       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
12123       if (counts == NULL)
12124         {
12125           free (lengths);
12126           error (_("Out of memory allocating space for histogram counts\n"));
12127           return FALSE;
12128         }
12129
12130       for (hn = 0; hn < nbuckets; ++hn)
12131         ++counts[lengths[hn]];
12132
12133       if (nbuckets > 0)
12134         {
12135           unsigned long i;
12136           printf ("      0  %-10lu (%5.1f%%)\n",
12137                   counts[0], (counts[0] * 100.0) / nbuckets);
12138           for (i = 1; i <= maxlength; ++i)
12139             {
12140               nzero_counts += counts[i] * i;
12141               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
12142                       i, counts[i], (counts[i] * 100.0) / nbuckets,
12143                       (nzero_counts * 100.0) / nsyms);
12144             }
12145         }
12146
12147       free (counts);
12148       free (lengths);
12149     }
12150
12151   if (buckets != NULL)
12152     {
12153       free (buckets);
12154       free (chains);
12155     }
12156
12157   if (do_histogram && gnubuckets != NULL)
12158     {
12159       unsigned long * lengths;
12160       unsigned long * counts;
12161       unsigned long hn;
12162       unsigned long maxlength = 0;
12163       unsigned long nzero_counts = 0;
12164       unsigned long nsyms = 0;
12165
12166       printf (ngettext ("\nHistogram for `%s' bucket list length "
12167                         "(total of %lu bucket):\n",
12168                         "\nHistogram for `%s' bucket list length "
12169                         "(total of %lu buckets):\n",
12170                         (unsigned long) ngnubuckets),
12171               GNU_HASH_SECTION_NAME,
12172               (unsigned long) ngnubuckets);
12173
12174       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
12175       if (lengths == NULL)
12176         {
12177           error (_("Out of memory allocating space for gnu histogram buckets\n"));
12178           return FALSE;
12179         }
12180
12181       printf (_(" Length  Number     %% of total  Coverage\n"));
12182
12183       for (hn = 0; hn < ngnubuckets; ++hn)
12184         if (gnubuckets[hn] != 0)
12185           {
12186             bfd_vma off, length = 1;
12187
12188             for (off = gnubuckets[hn] - gnusymidx;
12189                  /* PR 17531 file: 010-77222-0.004.  */
12190                  off < ngnuchains && (gnuchains[off] & 1) == 0;
12191                  ++off)
12192               ++length;
12193             lengths[hn] = length;
12194             if (length > maxlength)
12195               maxlength = length;
12196             nsyms += length;
12197           }
12198
12199       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
12200       if (counts == NULL)
12201         {
12202           free (lengths);
12203           error (_("Out of memory allocating space for gnu histogram counts\n"));
12204           return FALSE;
12205         }
12206
12207       for (hn = 0; hn < ngnubuckets; ++hn)
12208         ++counts[lengths[hn]];
12209
12210       if (ngnubuckets > 0)
12211         {
12212           unsigned long j;
12213           printf ("      0  %-10lu (%5.1f%%)\n",
12214                   counts[0], (counts[0] * 100.0) / ngnubuckets);
12215           for (j = 1; j <= maxlength; ++j)
12216             {
12217               nzero_counts += counts[j] * j;
12218               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
12219                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
12220                       (nzero_counts * 100.0) / nsyms);
12221             }
12222         }
12223
12224       free (counts);
12225       free (lengths);
12226       free (gnubuckets);
12227       free (gnuchains);
12228       free (mipsxlat);
12229     }
12230
12231   return TRUE;
12232 }
12233
12234 static bfd_boolean
12235 process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
12236 {
12237   unsigned int i;
12238
12239   if (dynamic_syminfo == NULL
12240       || !do_dynamic)
12241     /* No syminfo, this is ok.  */
12242     return TRUE;
12243
12244   /* There better should be a dynamic symbol section.  */
12245   if (dynamic_symbols == NULL || dynamic_strings == NULL)
12246     return FALSE;
12247
12248   if (dynamic_addr)
12249     printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12250                       "contains %d entry:\n",
12251                       "\nDynamic info segment at offset 0x%lx "
12252                       "contains %d entries:\n",
12253                       dynamic_syminfo_nent),
12254             dynamic_syminfo_offset, dynamic_syminfo_nent);
12255
12256   printf (_(" Num: Name                           BoundTo     Flags\n"));
12257   for (i = 0; i < dynamic_syminfo_nent; ++i)
12258     {
12259       unsigned short int flags = dynamic_syminfo[i].si_flags;
12260
12261       printf ("%4d: ", i);
12262       if (i >= num_dynamic_syms)
12263         printf (_("<corrupt index>"));
12264       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
12265         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
12266       else
12267         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
12268       putchar (' ');
12269
12270       switch (dynamic_syminfo[i].si_boundto)
12271         {
12272         case SYMINFO_BT_SELF:
12273           fputs ("SELF       ", stdout);
12274           break;
12275         case SYMINFO_BT_PARENT:
12276           fputs ("PARENT     ", stdout);
12277           break;
12278         default:
12279           if (dynamic_syminfo[i].si_boundto > 0
12280               && dynamic_syminfo[i].si_boundto < dynamic_nent
12281               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
12282             {
12283               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
12284               putchar (' ' );
12285             }
12286           else
12287             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
12288           break;
12289         }
12290
12291       if (flags & SYMINFO_FLG_DIRECT)
12292         printf (" DIRECT");
12293       if (flags & SYMINFO_FLG_PASSTHRU)
12294         printf (" PASSTHRU");
12295       if (flags & SYMINFO_FLG_COPY)
12296         printf (" COPY");
12297       if (flags & SYMINFO_FLG_LAZYLOAD)
12298         printf (" LAZYLOAD");
12299
12300       puts ("");
12301     }
12302
12303   return TRUE;
12304 }
12305
12306 #define IN_RANGE(START,END,ADDR,OFF)            \
12307   (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12308
12309 /* Check to see if the given reloc needs to be handled in a target specific
12310    manner.  If so then process the reloc and return TRUE otherwise return
12311    FALSE.
12312
12313    If called with reloc == NULL, then this is a signal that reloc processing
12314    for the current section has finished, and any saved state should be
12315    discarded.  */
12316
12317 static bfd_boolean
12318 target_specific_reloc_handling (Filedata *           filedata,
12319                                 Elf_Internal_Rela *  reloc,
12320                                 unsigned char *      start,
12321                                 unsigned char *      end,
12322                                 Elf_Internal_Sym *   symtab,
12323                                 unsigned long        num_syms)
12324 {
12325   unsigned int reloc_type = 0;
12326   unsigned long sym_index = 0;
12327
12328   if (reloc)
12329     {
12330       reloc_type = get_reloc_type (filedata, reloc->r_info);
12331       sym_index = get_reloc_symindex (reloc->r_info);
12332     }
12333
12334   switch (filedata->file_header.e_machine)
12335     {
12336     case EM_MSP430:
12337     case EM_MSP430_OLD:
12338       {
12339         static Elf_Internal_Sym * saved_sym = NULL;
12340
12341         if (reloc == NULL)
12342           {
12343             saved_sym = NULL;
12344             return TRUE;
12345           }
12346
12347         switch (reloc_type)
12348           {
12349           case 10: /* R_MSP430_SYM_DIFF */
12350             if (uses_msp430x_relocs (filedata))
12351               break;
12352             /* Fall through.  */
12353           case 21: /* R_MSP430X_SYM_DIFF */
12354             /* PR 21139.  */
12355             if (sym_index >= num_syms)
12356               error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12357                      sym_index);
12358             else
12359               saved_sym = symtab + sym_index;
12360             return TRUE;
12361
12362           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12363           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12364             goto handle_sym_diff;
12365
12366           case 5: /* R_MSP430_16_BYTE */
12367           case 9: /* R_MSP430_8 */
12368             if (uses_msp430x_relocs (filedata))
12369               break;
12370             goto handle_sym_diff;
12371
12372           case 2: /* R_MSP430_ABS16 */
12373           case 15: /* R_MSP430X_ABS16 */
12374             if (! uses_msp430x_relocs (filedata))
12375               break;
12376             goto handle_sym_diff;
12377
12378           handle_sym_diff:
12379             if (saved_sym != NULL)
12380               {
12381                 int reloc_size = reloc_type == 1 ? 4 : 2;
12382                 bfd_vma value;
12383
12384                 if (sym_index >= num_syms)
12385                   error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12386                          sym_index);
12387                 else
12388                   {
12389                     value = reloc->r_addend + (symtab[sym_index].st_value
12390                                                - saved_sym->st_value);
12391
12392                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12393                       byte_put (start + reloc->r_offset, value, reloc_size);
12394                     else
12395                       /* PR 21137 */
12396                       error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12397                              (long) reloc->r_offset);
12398                   }
12399
12400                 saved_sym = NULL;
12401                 return TRUE;
12402               }
12403             break;
12404
12405           default:
12406             if (saved_sym != NULL)
12407               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12408             break;
12409           }
12410         break;
12411       }
12412
12413     case EM_MN10300:
12414     case EM_CYGNUS_MN10300:
12415       {
12416         static Elf_Internal_Sym * saved_sym = NULL;
12417
12418         if (reloc == NULL)
12419           {
12420             saved_sym = NULL;
12421             return TRUE;
12422           }
12423
12424         switch (reloc_type)
12425           {
12426           case 34: /* R_MN10300_ALIGN */
12427             return TRUE;
12428           case 33: /* R_MN10300_SYM_DIFF */
12429             if (sym_index >= num_syms)
12430               error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12431                      sym_index);
12432             else
12433               saved_sym = symtab + sym_index;
12434             return TRUE;
12435
12436           case 1: /* R_MN10300_32 */
12437           case 2: /* R_MN10300_16 */
12438             if (saved_sym != NULL)
12439               {
12440                 int reloc_size = reloc_type == 1 ? 4 : 2;
12441                 bfd_vma value;
12442
12443                 if (sym_index >= num_syms)
12444                   error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12445                          sym_index);
12446                 else
12447                   {
12448                     value = reloc->r_addend + (symtab[sym_index].st_value
12449                                                - saved_sym->st_value);
12450
12451                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12452                       byte_put (start + reloc->r_offset, value, reloc_size);
12453                     else
12454                       error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12455                              (long) reloc->r_offset);
12456                   }
12457
12458                 saved_sym = NULL;
12459                 return TRUE;
12460               }
12461             break;
12462           default:
12463             if (saved_sym != NULL)
12464               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12465             break;
12466           }
12467         break;
12468       }
12469
12470     case EM_RL78:
12471       {
12472         static bfd_vma saved_sym1 = 0;
12473         static bfd_vma saved_sym2 = 0;
12474         static bfd_vma value;
12475
12476         if (reloc == NULL)
12477           {
12478             saved_sym1 = saved_sym2 = 0;
12479             return TRUE;
12480           }
12481
12482         switch (reloc_type)
12483           {
12484           case 0x80: /* R_RL78_SYM.  */
12485             saved_sym1 = saved_sym2;
12486             if (sym_index >= num_syms)
12487               error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12488                      sym_index);
12489             else
12490               {
12491                 saved_sym2 = symtab[sym_index].st_value;
12492                 saved_sym2 += reloc->r_addend;
12493               }
12494             return TRUE;
12495
12496           case 0x83: /* R_RL78_OPsub.  */
12497             value = saved_sym1 - saved_sym2;
12498             saved_sym2 = saved_sym1 = 0;
12499             return TRUE;
12500             break;
12501
12502           case 0x41: /* R_RL78_ABS32.  */
12503             if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12504               byte_put (start + reloc->r_offset, value, 4);
12505             else
12506               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12507                      (long) reloc->r_offset);
12508             value = 0;
12509             return TRUE;
12510
12511           case 0x43: /* R_RL78_ABS16.  */
12512             if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12513               byte_put (start + reloc->r_offset, value, 2);
12514             else
12515               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12516                      (long) reloc->r_offset);
12517             value = 0;
12518             return TRUE;
12519
12520           default:
12521             break;
12522           }
12523         break;
12524       }
12525     }
12526
12527   return FALSE;
12528 }
12529
12530 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12531    DWARF debug sections.  This is a target specific test.  Note - we do not
12532    go through the whole including-target-headers-multiple-times route, (as
12533    we have already done with <elf/h8.h>) because this would become very
12534    messy and even then this function would have to contain target specific
12535    information (the names of the relocs instead of their numeric values).
12536    FIXME: This is not the correct way to solve this problem.  The proper way
12537    is to have target specific reloc sizing and typing functions created by
12538    the reloc-macros.h header, in the same way that it already creates the
12539    reloc naming functions.  */
12540
12541 static bfd_boolean
12542 is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12543 {
12544   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12545   switch (filedata->file_header.e_machine)
12546     {
12547     case EM_386:
12548     case EM_IAMCU:
12549       return reloc_type == 1; /* R_386_32.  */
12550     case EM_68K:
12551       return reloc_type == 1; /* R_68K_32.  */
12552     case EM_860:
12553       return reloc_type == 1; /* R_860_32.  */
12554     case EM_960:
12555       return reloc_type == 2; /* R_960_32.  */
12556     case EM_AARCH64:
12557       return (reloc_type == 258
12558               || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12559     case EM_BPF:
12560       return reloc_type == 11; /* R_BPF_DATA_32 */
12561     case EM_ADAPTEVA_EPIPHANY:
12562       return reloc_type == 3;
12563     case EM_ALPHA:
12564       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
12565     case EM_ARC:
12566       return reloc_type == 1; /* R_ARC_32.  */
12567     case EM_ARC_COMPACT:
12568     case EM_ARC_COMPACT2:
12569       return reloc_type == 4; /* R_ARC_32.  */
12570     case EM_ARM:
12571       return reloc_type == 2; /* R_ARM_ABS32 */
12572     case EM_AVR_OLD:
12573     case EM_AVR:
12574       return reloc_type == 1;
12575     case EM_BLACKFIN:
12576       return reloc_type == 0x12; /* R_byte4_data.  */
12577     case EM_CRIS:
12578       return reloc_type == 3; /* R_CRIS_32.  */
12579     case EM_CR16:
12580       return reloc_type == 3; /* R_CR16_NUM32.  */
12581     case EM_CRX:
12582       return reloc_type == 15; /* R_CRX_NUM32.  */
12583     case EM_CSKY:
12584       return reloc_type == 1; /* R_CKCORE_ADDR32.  */
12585     case EM_CYGNUS_FRV:
12586       return reloc_type == 1;
12587     case EM_CYGNUS_D10V:
12588     case EM_D10V:
12589       return reloc_type == 6; /* R_D10V_32.  */
12590     case EM_CYGNUS_D30V:
12591     case EM_D30V:
12592       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
12593     case EM_DLX:
12594       return reloc_type == 3; /* R_DLX_RELOC_32.  */
12595     case EM_CYGNUS_FR30:
12596     case EM_FR30:
12597       return reloc_type == 3; /* R_FR30_32.  */
12598     case EM_FT32:
12599       return reloc_type == 1; /* R_FT32_32.  */
12600     case EM_H8S:
12601     case EM_H8_300:
12602     case EM_H8_300H:
12603       return reloc_type == 1; /* R_H8_DIR32.  */
12604     case EM_IA_64:
12605       return (reloc_type == 0x64    /* R_IA64_SECREL32MSB.  */
12606               || reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
12607               || reloc_type == 0x24 /* R_IA64_DIR32MSB.  */
12608               || reloc_type == 0x25 /* R_IA64_DIR32LSB.  */);
12609     case EM_IP2K_OLD:
12610     case EM_IP2K:
12611       return reloc_type == 2; /* R_IP2K_32.  */
12612     case EM_IQ2000:
12613       return reloc_type == 2; /* R_IQ2000_32.  */
12614     case EM_LATTICEMICO32:
12615       return reloc_type == 3; /* R_LM32_32.  */
12616     case EM_M32C_OLD:
12617     case EM_M32C:
12618       return reloc_type == 3; /* R_M32C_32.  */
12619     case EM_M32R:
12620       return reloc_type == 34; /* R_M32R_32_RELA.  */
12621     case EM_68HC11:
12622     case EM_68HC12:
12623       return reloc_type == 6; /* R_M68HC11_32.  */
12624     case EM_S12Z:
12625       return reloc_type == 7 || /* R_S12Z_EXT32 */
12626         reloc_type == 6;        /* R_S12Z_CW32.  */
12627     case EM_MCORE:
12628       return reloc_type == 1; /* R_MCORE_ADDR32.  */
12629     case EM_CYGNUS_MEP:
12630       return reloc_type == 4; /* R_MEP_32.  */
12631     case EM_METAG:
12632       return reloc_type == 2; /* R_METAG_ADDR32.  */
12633     case EM_MICROBLAZE:
12634       return reloc_type == 1; /* R_MICROBLAZE_32.  */
12635     case EM_MIPS:
12636       return reloc_type == 2; /* R_MIPS_32.  */
12637     case EM_MMIX:
12638       return reloc_type == 4; /* R_MMIX_32.  */
12639     case EM_CYGNUS_MN10200:
12640     case EM_MN10200:
12641       return reloc_type == 1; /* R_MN10200_32.  */
12642     case EM_CYGNUS_MN10300:
12643     case EM_MN10300:
12644       return reloc_type == 1; /* R_MN10300_32.  */
12645     case EM_MOXIE:
12646       return reloc_type == 1; /* R_MOXIE_32.  */
12647     case EM_MSP430_OLD:
12648     case EM_MSP430:
12649       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
12650     case EM_MT:
12651       return reloc_type == 2; /* R_MT_32.  */
12652     case EM_NDS32:
12653       return reloc_type == 20; /* R_NDS32_RELA.  */
12654     case EM_ALTERA_NIOS2:
12655       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
12656     case EM_NIOS32:
12657       return reloc_type == 1; /* R_NIOS_32.  */
12658     case EM_OR1K:
12659       return reloc_type == 1; /* R_OR1K_32.  */
12660     case EM_PARISC:
12661       return (reloc_type == 1 /* R_PARISC_DIR32.  */
12662               || reloc_type == 2 /* R_PARISC_DIR21L.  */
12663               || reloc_type == 41); /* R_PARISC_SECREL32.  */
12664     case EM_PJ:
12665     case EM_PJ_OLD:
12666       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
12667     case EM_PPC64:
12668       return reloc_type == 1; /* R_PPC64_ADDR32.  */
12669     case EM_PPC:
12670       return reloc_type == 1; /* R_PPC_ADDR32.  */
12671     case EM_TI_PRU:
12672       return reloc_type == 11; /* R_PRU_BFD_RELOC_32.  */
12673     case EM_RISCV:
12674       return reloc_type == 1; /* R_RISCV_32.  */
12675     case EM_RL78:
12676       return reloc_type == 1; /* R_RL78_DIR32.  */
12677     case EM_RX:
12678       return reloc_type == 1; /* R_RX_DIR32.  */
12679     case EM_S370:
12680       return reloc_type == 1; /* R_I370_ADDR31.  */
12681     case EM_S390_OLD:
12682     case EM_S390:
12683       return reloc_type == 4; /* R_S390_32.  */
12684     case EM_SCORE:
12685       return reloc_type == 8; /* R_SCORE_ABS32.  */
12686     case EM_SH:
12687       return reloc_type == 1; /* R_SH_DIR32.  */
12688     case EM_SPARC32PLUS:
12689     case EM_SPARCV9:
12690     case EM_SPARC:
12691       return reloc_type == 3 /* R_SPARC_32.  */
12692         || reloc_type == 23; /* R_SPARC_UA32.  */
12693     case EM_SPU:
12694       return reloc_type == 6; /* R_SPU_ADDR32 */
12695     case EM_TI_C6000:
12696       return reloc_type == 1; /* R_C6000_ABS32.  */
12697     case EM_TILEGX:
12698       return reloc_type == 2; /* R_TILEGX_32.  */
12699     case EM_TILEPRO:
12700       return reloc_type == 1; /* R_TILEPRO_32.  */
12701     case EM_CYGNUS_V850:
12702     case EM_V850:
12703       return reloc_type == 6; /* R_V850_ABS32.  */
12704     case EM_V800:
12705       return reloc_type == 0x33; /* R_V810_WORD.  */
12706     case EM_VAX:
12707       return reloc_type == 1; /* R_VAX_32.  */
12708     case EM_VISIUM:
12709       return reloc_type == 3;  /* R_VISIUM_32. */
12710     case EM_WEBASSEMBLY:
12711       return reloc_type == 1;  /* R_WASM32_32.  */
12712     case EM_X86_64:
12713     case EM_L1OM:
12714     case EM_K1OM:
12715       return reloc_type == 10; /* R_X86_64_32.  */
12716     case EM_XC16X:
12717     case EM_C166:
12718       return reloc_type == 3; /* R_XC16C_ABS_32.  */
12719     case EM_XGATE:
12720       return reloc_type == 4; /* R_XGATE_32.  */
12721     case EM_XSTORMY16:
12722       return reloc_type == 1; /* R_XSTROMY16_32.  */
12723     case EM_XTENSA_OLD:
12724     case EM_XTENSA:
12725       return reloc_type == 1; /* R_XTENSA_32.  */
12726     default:
12727       {
12728         static unsigned int prev_warn = 0;
12729
12730         /* Avoid repeating the same warning multiple times.  */
12731         if (prev_warn != filedata->file_header.e_machine)
12732           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12733                  filedata->file_header.e_machine);
12734         prev_warn = filedata->file_header.e_machine;
12735         return FALSE;
12736       }
12737     }
12738 }
12739
12740 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12741    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
12742
12743 static bfd_boolean
12744 is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12745 {
12746   switch (filedata->file_header.e_machine)
12747   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12748     {
12749     case EM_386:
12750     case EM_IAMCU:
12751       return reloc_type == 2;  /* R_386_PC32.  */
12752     case EM_68K:
12753       return reloc_type == 4;  /* R_68K_PC32.  */
12754     case EM_AARCH64:
12755       return reloc_type == 261; /* R_AARCH64_PREL32 */
12756     case EM_ADAPTEVA_EPIPHANY:
12757       return reloc_type == 6;
12758     case EM_ALPHA:
12759       return reloc_type == 10; /* R_ALPHA_SREL32.  */
12760     case EM_ARC_COMPACT:
12761     case EM_ARC_COMPACT2:
12762       return reloc_type == 49; /* R_ARC_32_PCREL.  */
12763     case EM_ARM:
12764       return reloc_type == 3;  /* R_ARM_REL32 */
12765     case EM_AVR_OLD:
12766     case EM_AVR:
12767       return reloc_type == 36; /* R_AVR_32_PCREL.  */
12768     case EM_MICROBLAZE:
12769       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
12770     case EM_OR1K:
12771       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
12772     case EM_PARISC:
12773       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
12774     case EM_PPC:
12775       return reloc_type == 26; /* R_PPC_REL32.  */
12776     case EM_PPC64:
12777       return reloc_type == 26; /* R_PPC64_REL32.  */
12778     case EM_RISCV:
12779       return reloc_type == 57;  /* R_RISCV_32_PCREL.  */
12780     case EM_S390_OLD:
12781     case EM_S390:
12782       return reloc_type == 5;  /* R_390_PC32.  */
12783     case EM_SH:
12784       return reloc_type == 2;  /* R_SH_REL32.  */
12785     case EM_SPARC32PLUS:
12786     case EM_SPARCV9:
12787     case EM_SPARC:
12788       return reloc_type == 6;  /* R_SPARC_DISP32.  */
12789     case EM_SPU:
12790       return reloc_type == 13; /* R_SPU_REL32.  */
12791     case EM_TILEGX:
12792       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
12793     case EM_TILEPRO:
12794       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
12795     case EM_VISIUM:
12796       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
12797     case EM_X86_64:
12798     case EM_L1OM:
12799     case EM_K1OM:
12800       return reloc_type == 2;  /* R_X86_64_PC32.  */
12801     case EM_VAX:
12802       return reloc_type == 4;  /* R_VAX_PCREL32.  */
12803     case EM_XTENSA_OLD:
12804     case EM_XTENSA:
12805       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
12806     default:
12807       /* Do not abort or issue an error message here.  Not all targets use
12808          pc-relative 32-bit relocs in their DWARF debug information and we
12809          have already tested for target coverage in is_32bit_abs_reloc.  A
12810          more helpful warning message will be generated by apply_relocations
12811          anyway, so just return.  */
12812       return FALSE;
12813     }
12814 }
12815
12816 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12817    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
12818
12819 static bfd_boolean
12820 is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12821 {
12822   switch (filedata->file_header.e_machine)
12823     {
12824     case EM_AARCH64:
12825       return reloc_type == 257; /* R_AARCH64_ABS64.  */
12826     case EM_ALPHA:
12827       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
12828     case EM_IA_64:
12829       return (reloc_type == 0x26    /* R_IA64_DIR64MSB.  */
12830               || reloc_type == 0x27 /* R_IA64_DIR64LSB.  */);
12831     case EM_PARISC:
12832       return reloc_type == 80; /* R_PARISC_DIR64.  */
12833     case EM_PPC64:
12834       return reloc_type == 38; /* R_PPC64_ADDR64.  */
12835     case EM_RISCV:
12836       return reloc_type == 2; /* R_RISCV_64.  */
12837     case EM_SPARC32PLUS:
12838     case EM_SPARCV9:
12839     case EM_SPARC:
12840       return reloc_type == 32 /* R_SPARC_64.  */
12841         || reloc_type == 54; /* R_SPARC_UA64.  */
12842     case EM_X86_64:
12843     case EM_L1OM:
12844     case EM_K1OM:
12845       return reloc_type == 1; /* R_X86_64_64.  */
12846     case EM_S390_OLD:
12847     case EM_S390:
12848       return reloc_type == 22;  /* R_S390_64.  */
12849     case EM_TILEGX:
12850       return reloc_type == 1; /* R_TILEGX_64.  */
12851     case EM_MIPS:
12852       return reloc_type == 18;  /* R_MIPS_64.  */
12853     default:
12854       return FALSE;
12855     }
12856 }
12857
12858 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12859    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
12860
12861 static bfd_boolean
12862 is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12863 {
12864   switch (filedata->file_header.e_machine)
12865     {
12866     case EM_AARCH64:
12867       return reloc_type == 260; /* R_AARCH64_PREL64.  */
12868     case EM_ALPHA:
12869       return reloc_type == 11; /* R_ALPHA_SREL64.  */
12870     case EM_IA_64:
12871       return (reloc_type == 0x4e    /* R_IA64_PCREL64MSB.  */
12872               || reloc_type == 0x4f /* R_IA64_PCREL64LSB.  */);
12873     case EM_PARISC:
12874       return reloc_type == 72; /* R_PARISC_PCREL64.  */
12875     case EM_PPC64:
12876       return reloc_type == 44; /* R_PPC64_REL64.  */
12877     case EM_SPARC32PLUS:
12878     case EM_SPARCV9:
12879     case EM_SPARC:
12880       return reloc_type == 46; /* R_SPARC_DISP64.  */
12881     case EM_X86_64:
12882     case EM_L1OM:
12883     case EM_K1OM:
12884       return reloc_type == 24; /* R_X86_64_PC64.  */
12885     case EM_S390_OLD:
12886     case EM_S390:
12887       return reloc_type == 23;  /* R_S390_PC64.  */
12888     case EM_TILEGX:
12889       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
12890     default:
12891       return FALSE;
12892     }
12893 }
12894
12895 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12896    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
12897
12898 static bfd_boolean
12899 is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12900 {
12901   switch (filedata->file_header.e_machine)
12902     {
12903     case EM_CYGNUS_MN10200:
12904     case EM_MN10200:
12905       return reloc_type == 4; /* R_MN10200_24.  */
12906     case EM_FT32:
12907       return reloc_type == 5; /* R_FT32_20.  */
12908     default:
12909       return FALSE;
12910     }
12911 }
12912
12913 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12914    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
12915
12916 static bfd_boolean
12917 is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12918 {
12919   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12920   switch (filedata->file_header.e_machine)
12921     {
12922     case EM_ARC:
12923     case EM_ARC_COMPACT:
12924     case EM_ARC_COMPACT2:
12925       return reloc_type == 2; /* R_ARC_16.  */
12926     case EM_ADAPTEVA_EPIPHANY:
12927       return reloc_type == 5;
12928     case EM_AVR_OLD:
12929     case EM_AVR:
12930       return reloc_type == 4; /* R_AVR_16.  */
12931     case EM_CYGNUS_D10V:
12932     case EM_D10V:
12933       return reloc_type == 3; /* R_D10V_16.  */
12934     case EM_FT32:
12935       return reloc_type == 2; /* R_FT32_16.  */
12936     case EM_H8S:
12937     case EM_H8_300:
12938     case EM_H8_300H:
12939       return reloc_type == R_H8_DIR16;
12940     case EM_IP2K_OLD:
12941     case EM_IP2K:
12942       return reloc_type == 1; /* R_IP2K_16.  */
12943     case EM_M32C_OLD:
12944     case EM_M32C:
12945       return reloc_type == 1; /* R_M32C_16 */
12946     case EM_CYGNUS_MN10200:
12947     case EM_MN10200:
12948       return reloc_type == 2; /* R_MN10200_16.  */
12949     case EM_CYGNUS_MN10300:
12950     case EM_MN10300:
12951       return reloc_type == 2; /* R_MN10300_16.  */
12952     case EM_MSP430:
12953       if (uses_msp430x_relocs (filedata))
12954         return reloc_type == 2; /* R_MSP430_ABS16.  */
12955       /* Fall through.  */
12956     case EM_MSP430_OLD:
12957       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
12958     case EM_NDS32:
12959       return reloc_type == 19; /* R_NDS32_RELA.  */
12960     case EM_ALTERA_NIOS2:
12961       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
12962     case EM_NIOS32:
12963       return reloc_type == 9; /* R_NIOS_16.  */
12964     case EM_OR1K:
12965       return reloc_type == 2; /* R_OR1K_16.  */
12966     case EM_RISCV:
12967       return reloc_type == 55; /* R_RISCV_SET16.  */
12968     case EM_TI_PRU:
12969       return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
12970     case EM_TI_C6000:
12971       return reloc_type == 2; /* R_C6000_ABS16.  */
12972     case EM_VISIUM:
12973       return reloc_type == 2; /* R_VISIUM_16. */
12974     case EM_XC16X:
12975     case EM_C166:
12976       return reloc_type == 2; /* R_XC16C_ABS_16.  */
12977     case EM_XGATE:
12978       return reloc_type == 3; /* R_XGATE_16.  */
12979     default:
12980       return FALSE;
12981     }
12982 }
12983
12984 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12985    a 8-bit absolute RELA relocation used in DWARF debug sections.  */
12986
12987 static bfd_boolean
12988 is_8bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12989 {
12990   switch (filedata->file_header.e_machine)
12991     {
12992     case EM_RISCV:
12993       return reloc_type == 54; /* R_RISCV_SET8.  */
12994     default:
12995       return FALSE;
12996     }
12997 }
12998
12999 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13000    a 6-bit absolute RELA relocation used in DWARF debug sections.  */
13001
13002 static bfd_boolean
13003 is_6bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
13004 {
13005   switch (filedata->file_header.e_machine)
13006     {
13007     case EM_RISCV:
13008       return reloc_type == 53; /* R_RISCV_SET6.  */
13009     default:
13010       return FALSE;
13011     }
13012 }
13013
13014 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13015    a 32-bit inplace add RELA relocation used in DWARF debug sections.  */
13016
13017 static bfd_boolean
13018 is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13019 {
13020   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13021   switch (filedata->file_header.e_machine)
13022     {
13023     case EM_RISCV:
13024       return reloc_type == 35; /* R_RISCV_ADD32.  */
13025     default:
13026       return FALSE;
13027     }
13028 }
13029
13030 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13031    a 32-bit inplace sub RELA relocation used in DWARF debug sections.  */
13032
13033 static bfd_boolean
13034 is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13035 {
13036   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13037   switch (filedata->file_header.e_machine)
13038     {
13039     case EM_RISCV:
13040       return reloc_type == 39; /* R_RISCV_SUB32.  */
13041     default:
13042       return FALSE;
13043     }
13044 }
13045
13046 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13047    a 64-bit inplace add RELA relocation used in DWARF debug sections.  */
13048
13049 static bfd_boolean
13050 is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13051 {
13052   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13053   switch (filedata->file_header.e_machine)
13054     {
13055     case EM_RISCV:
13056       return reloc_type == 36; /* R_RISCV_ADD64.  */
13057     default:
13058       return FALSE;
13059     }
13060 }
13061
13062 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13063    a 64-bit inplace sub RELA relocation used in DWARF debug sections.  */
13064
13065 static bfd_boolean
13066 is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13067 {
13068   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13069   switch (filedata->file_header.e_machine)
13070     {
13071     case EM_RISCV:
13072       return reloc_type == 40; /* R_RISCV_SUB64.  */
13073     default:
13074       return FALSE;
13075     }
13076 }
13077
13078 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13079    a 16-bit inplace add RELA relocation used in DWARF debug sections.  */
13080
13081 static bfd_boolean
13082 is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13083 {
13084   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13085   switch (filedata->file_header.e_machine)
13086     {
13087     case EM_RISCV:
13088       return reloc_type == 34; /* R_RISCV_ADD16.  */
13089     default:
13090       return FALSE;
13091     }
13092 }
13093
13094 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13095    a 16-bit inplace sub RELA relocation used in DWARF debug sections.  */
13096
13097 static bfd_boolean
13098 is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13099 {
13100   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13101   switch (filedata->file_header.e_machine)
13102     {
13103     case EM_RISCV:
13104       return reloc_type == 38; /* R_RISCV_SUB16.  */
13105     default:
13106       return FALSE;
13107     }
13108 }
13109
13110 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13111    a 8-bit inplace add RELA relocation used in DWARF debug sections.  */
13112
13113 static bfd_boolean
13114 is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13115 {
13116   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13117   switch (filedata->file_header.e_machine)
13118     {
13119     case EM_RISCV:
13120       return reloc_type == 33; /* R_RISCV_ADD8.  */
13121     default:
13122       return FALSE;
13123     }
13124 }
13125
13126 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13127    a 8-bit inplace sub RELA relocation used in DWARF debug sections.  */
13128
13129 static bfd_boolean
13130 is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13131 {
13132   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13133   switch (filedata->file_header.e_machine)
13134     {
13135     case EM_RISCV:
13136       return reloc_type == 37; /* R_RISCV_SUB8.  */
13137     default:
13138       return FALSE;
13139     }
13140 }
13141
13142 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13143    a 6-bit inplace sub RELA relocation used in DWARF debug sections.  */
13144
13145 static bfd_boolean
13146 is_6bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13147 {
13148   switch (filedata->file_header.e_machine)
13149     {
13150     case EM_RISCV:
13151       return reloc_type == 52; /* R_RISCV_SUB6.  */
13152     default:
13153       return FALSE;
13154     }
13155 }
13156
13157 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13158    relocation entries (possibly formerly used for SHT_GROUP sections).  */
13159
13160 static bfd_boolean
13161 is_none_reloc (Filedata * filedata, unsigned int reloc_type)
13162 {
13163   switch (filedata->file_header.e_machine)
13164     {
13165     case EM_386:     /* R_386_NONE.  */
13166     case EM_68K:     /* R_68K_NONE.  */
13167     case EM_ADAPTEVA_EPIPHANY:
13168     case EM_ALPHA:   /* R_ALPHA_NONE.  */
13169     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
13170     case EM_ARC:     /* R_ARC_NONE.  */
13171     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
13172     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
13173     case EM_ARM:     /* R_ARM_NONE.  */
13174     case EM_C166:    /* R_XC16X_NONE.  */
13175     case EM_CRIS:    /* R_CRIS_NONE.  */
13176     case EM_FT32:    /* R_FT32_NONE.  */
13177     case EM_IA_64:   /* R_IA64_NONE.  */
13178     case EM_K1OM:    /* R_X86_64_NONE.  */
13179     case EM_L1OM:    /* R_X86_64_NONE.  */
13180     case EM_M32R:    /* R_M32R_NONE.  */
13181     case EM_MIPS:    /* R_MIPS_NONE.  */
13182     case EM_MN10300: /* R_MN10300_NONE.  */
13183     case EM_MOXIE:   /* R_MOXIE_NONE.  */
13184     case EM_NIOS32:  /* R_NIOS_NONE.  */
13185     case EM_OR1K:    /* R_OR1K_NONE. */
13186     case EM_PARISC:  /* R_PARISC_NONE.  */
13187     case EM_PPC64:   /* R_PPC64_NONE.  */
13188     case EM_PPC:     /* R_PPC_NONE.  */
13189     case EM_RISCV:   /* R_RISCV_NONE.  */
13190     case EM_S390:    /* R_390_NONE.  */
13191     case EM_S390_OLD:
13192     case EM_SH:      /* R_SH_NONE.  */
13193     case EM_SPARC32PLUS:
13194     case EM_SPARC:   /* R_SPARC_NONE.  */
13195     case EM_SPARCV9:
13196     case EM_TILEGX:  /* R_TILEGX_NONE.  */
13197     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
13198     case EM_TI_C6000:/* R_C6000_NONE.  */
13199     case EM_X86_64:  /* R_X86_64_NONE.  */
13200     case EM_XC16X:
13201     case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
13202       return reloc_type == 0;
13203
13204     case EM_AARCH64:
13205       return reloc_type == 0 || reloc_type == 256;
13206     case EM_AVR_OLD:
13207     case EM_AVR:
13208       return (reloc_type == 0 /* R_AVR_NONE.  */
13209               || reloc_type == 30 /* R_AVR_DIFF8.  */
13210               || reloc_type == 31 /* R_AVR_DIFF16.  */
13211               || reloc_type == 32 /* R_AVR_DIFF32.  */);
13212     case EM_METAG:
13213       return reloc_type == 3; /* R_METAG_NONE.  */
13214     case EM_NDS32:
13215       return (reloc_type == 0       /* R_XTENSA_NONE.  */
13216               || reloc_type == 204  /* R_NDS32_DIFF8.  */
13217               || reloc_type == 205  /* R_NDS32_DIFF16.  */
13218               || reloc_type == 206  /* R_NDS32_DIFF32.  */
13219               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
13220     case EM_TI_PRU:
13221       return (reloc_type == 0       /* R_PRU_NONE.  */
13222               || reloc_type == 65   /* R_PRU_DIFF8.  */
13223               || reloc_type == 66   /* R_PRU_DIFF16.  */
13224               || reloc_type == 67   /* R_PRU_DIFF32.  */);
13225     case EM_XTENSA_OLD:
13226     case EM_XTENSA:
13227       return (reloc_type == 0      /* R_XTENSA_NONE.  */
13228               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
13229               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
13230               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
13231     }
13232   return FALSE;
13233 }
13234
13235 /* Returns TRUE if there is a relocation against
13236    section NAME at OFFSET bytes.  */
13237
13238 bfd_boolean
13239 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
13240 {
13241   Elf_Internal_Rela * relocs;
13242   Elf_Internal_Rela * rp;
13243
13244   if (dsec == NULL || dsec->reloc_info == NULL)
13245     return FALSE;
13246
13247   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
13248
13249   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
13250     if (rp->r_offset == offset)
13251       return TRUE;
13252
13253    return FALSE;
13254 }
13255
13256 /* Apply relocations to a section.
13257    Returns TRUE upon success, FALSE otherwise.
13258    If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13259    It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
13260    will be set to the number of relocs loaded.
13261
13262    Note: So far support has been added only for those relocations
13263    which can be found in debug sections. FIXME: Add support for
13264    more relocations ?  */
13265
13266 static bfd_boolean
13267 apply_relocations (Filedata *                 filedata,
13268                    const Elf_Internal_Shdr *  section,
13269                    unsigned char *            start,
13270                    bfd_size_type              size,
13271                    void **                    relocs_return,
13272                    unsigned long *            num_relocs_return)
13273 {
13274   Elf_Internal_Shdr * relsec;
13275   unsigned char * end = start + size;
13276
13277   if (relocs_return != NULL)
13278     {
13279       * (Elf_Internal_Rela **) relocs_return = NULL;
13280       * num_relocs_return = 0;
13281     }
13282
13283   if (filedata->file_header.e_type != ET_REL)
13284     /* No relocs to apply.  */
13285     return TRUE;
13286
13287   /* Find the reloc section associated with the section.  */
13288   for (relsec = filedata->section_headers;
13289        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13290        ++relsec)
13291     {
13292       bfd_boolean is_rela;
13293       unsigned long num_relocs;
13294       Elf_Internal_Rela * relocs;
13295       Elf_Internal_Rela * rp;
13296       Elf_Internal_Shdr * symsec;
13297       Elf_Internal_Sym * symtab;
13298       unsigned long num_syms;
13299       Elf_Internal_Sym * sym;
13300
13301       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13302           || relsec->sh_info >= filedata->file_header.e_shnum
13303           || filedata->section_headers + relsec->sh_info != section
13304           || relsec->sh_size == 0
13305           || relsec->sh_link >= filedata->file_header.e_shnum)
13306         continue;
13307
13308       is_rela = relsec->sh_type == SHT_RELA;
13309
13310       if (is_rela)
13311         {
13312           if (!slurp_rela_relocs (filedata, relsec->sh_offset,
13313                                   relsec->sh_size, & relocs, & num_relocs))
13314             return FALSE;
13315         }
13316       else
13317         {
13318           if (!slurp_rel_relocs (filedata, relsec->sh_offset,
13319                                  relsec->sh_size, & relocs, & num_relocs))
13320             return FALSE;
13321         }
13322
13323       /* SH uses RELA but uses in place value instead of the addend field.  */
13324       if (filedata->file_header.e_machine == EM_SH)
13325         is_rela = FALSE;
13326
13327       symsec = filedata->section_headers + relsec->sh_link;
13328       if (symsec->sh_type != SHT_SYMTAB
13329           && symsec->sh_type != SHT_DYNSYM)
13330         return FALSE;
13331       symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
13332
13333       for (rp = relocs; rp < relocs + num_relocs; ++rp)
13334         {
13335           bfd_vma         addend;
13336           unsigned int    reloc_type;
13337           unsigned int    reloc_size;
13338           bfd_boolean     reloc_inplace = FALSE;
13339           bfd_boolean     reloc_subtract = FALSE;
13340           unsigned char * rloc;
13341           unsigned long   sym_index;
13342
13343           reloc_type = get_reloc_type (filedata, rp->r_info);
13344
13345           if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
13346             continue;
13347           else if (is_none_reloc (filedata, reloc_type))
13348             continue;
13349           else if (is_32bit_abs_reloc (filedata, reloc_type)
13350                    || is_32bit_pcrel_reloc (filedata, reloc_type))
13351             reloc_size = 4;
13352           else if (is_64bit_abs_reloc (filedata, reloc_type)
13353                    || is_64bit_pcrel_reloc (filedata, reloc_type))
13354             reloc_size = 8;
13355           else if (is_24bit_abs_reloc (filedata, reloc_type))
13356             reloc_size = 3;
13357           else if (is_16bit_abs_reloc (filedata, reloc_type))
13358             reloc_size = 2;
13359           else if (is_8bit_abs_reloc (filedata, reloc_type)
13360                    || is_6bit_abs_reloc (filedata, reloc_type))
13361             reloc_size = 1;
13362           else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
13363                                                                  reloc_type))
13364                    || is_32bit_inplace_add_reloc (filedata, reloc_type))
13365             {
13366               reloc_size = 4;
13367               reloc_inplace = TRUE;
13368             }
13369           else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
13370                                                                  reloc_type))
13371                    || is_64bit_inplace_add_reloc (filedata, reloc_type))
13372             {
13373               reloc_size = 8;
13374               reloc_inplace = TRUE;
13375             }
13376           else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
13377                                                                  reloc_type))
13378                    || is_16bit_inplace_add_reloc (filedata, reloc_type))
13379             {
13380               reloc_size = 2;
13381               reloc_inplace = TRUE;
13382             }
13383           else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
13384                                                                 reloc_type))
13385                    || is_8bit_inplace_add_reloc (filedata, reloc_type))
13386             {
13387               reloc_size = 1;
13388               reloc_inplace = TRUE;
13389             }
13390           else if ((reloc_subtract = is_6bit_inplace_sub_reloc (filedata,
13391                                                                 reloc_type)))
13392             {
13393               reloc_size = 1;
13394               reloc_inplace = TRUE;
13395             }
13396           else
13397             {
13398               static unsigned int prev_reloc = 0;
13399
13400               if (reloc_type != prev_reloc)
13401                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13402                       reloc_type, printable_section_name (filedata, section));
13403               prev_reloc = reloc_type;
13404               continue;
13405             }
13406
13407           rloc = start + rp->r_offset;
13408           if (rloc >= end || (rloc + reloc_size) > end || (rloc < start))
13409             {
13410               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13411                     (unsigned long) rp->r_offset,
13412                     printable_section_name (filedata, section));
13413               continue;
13414             }
13415
13416           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
13417           if (sym_index >= num_syms)
13418             {
13419               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13420                     sym_index, printable_section_name (filedata, section));
13421               continue;
13422             }
13423           sym = symtab + sym_index;
13424
13425           /* If the reloc has a symbol associated with it,
13426              make sure that it is of an appropriate type.
13427
13428              Relocations against symbols without type can happen.
13429              Gcc -feliminate-dwarf2-dups may generate symbols
13430              without type for debug info.
13431
13432              Icc generates relocations against function symbols
13433              instead of local labels.
13434
13435              Relocations against object symbols can happen, eg when
13436              referencing a global array.  For an example of this see
13437              the _clz.o binary in libgcc.a.  */
13438           if (sym != symtab
13439               && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13440               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13441             {
13442               warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13443                     get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13444                     printable_section_name (filedata, relsec),
13445                     (long int)(rp - relocs));
13446               continue;
13447             }
13448
13449           addend = 0;
13450           if (is_rela)
13451             addend += rp->r_addend;
13452           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13453              partial_inplace.  */
13454           if (!is_rela
13455               || (filedata->file_header.e_machine == EM_XTENSA
13456                   && reloc_type == 1)
13457               || ((filedata->file_header.e_machine == EM_PJ
13458                    || filedata->file_header.e_machine == EM_PJ_OLD)
13459                   && reloc_type == 1)
13460               || ((filedata->file_header.e_machine == EM_D30V
13461                    || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13462                   && reloc_type == 12)
13463               || reloc_inplace)
13464             {
13465               if (is_6bit_inplace_sub_reloc (filedata, reloc_type))
13466                 addend += byte_get (rloc, reloc_size) & 0x3f;
13467               else
13468                 addend += byte_get (rloc, reloc_size);
13469             }
13470
13471           if (is_32bit_pcrel_reloc (filedata, reloc_type)
13472               || is_64bit_pcrel_reloc (filedata, reloc_type))
13473             {
13474               /* On HPPA, all pc-relative relocations are biased by 8.  */
13475               if (filedata->file_header.e_machine == EM_PARISC)
13476                 addend -= 8;
13477               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13478                         reloc_size);
13479             }
13480           else if (is_6bit_abs_reloc (filedata, reloc_type)
13481                    || is_6bit_inplace_sub_reloc (filedata, reloc_type))
13482             {
13483               if (reloc_subtract)
13484                 addend -= sym->st_value;
13485               else
13486                 addend += sym->st_value;
13487               addend = (addend & 0x3f) | (byte_get (rloc, reloc_size) & 0xc0);
13488               byte_put (rloc, addend, reloc_size);
13489             }
13490           else if (reloc_subtract)
13491             byte_put (rloc, addend - sym->st_value, reloc_size);
13492           else
13493             byte_put (rloc, addend + sym->st_value, reloc_size);
13494         }
13495
13496       free (symtab);
13497       /* Let the target specific reloc processing code know that
13498          we have finished with these relocs.  */
13499       target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13500
13501       if (relocs_return)
13502         {
13503           * (Elf_Internal_Rela **) relocs_return = relocs;
13504           * num_relocs_return = num_relocs;
13505         }
13506       else
13507         free (relocs);
13508
13509       break;
13510     }
13511
13512   return TRUE;
13513 }
13514
13515 #ifdef SUPPORT_DISASSEMBLY
13516 static bfd_boolean
13517 disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13518 {
13519   printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13520
13521   /* FIXME: XXX -- to be done --- XXX */
13522
13523   return TRUE;
13524 }
13525 #endif
13526
13527 /* Reads in the contents of SECTION from FILE, returning a pointer
13528    to a malloc'ed buffer or NULL if something went wrong.  */
13529
13530 static char *
13531 get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13532 {
13533   bfd_size_type num_bytes = section->sh_size;
13534
13535   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13536     {
13537       printf (_("Section '%s' has no data to dump.\n"),
13538               printable_section_name (filedata, section));
13539       return NULL;
13540     }
13541
13542   return  (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13543                              _("section contents"));
13544 }
13545
13546 /* Uncompresses a section that was compressed using zlib, in place.  */
13547
13548 static bfd_boolean
13549 uncompress_section_contents (unsigned char **   buffer,
13550                              dwarf_size_type    uncompressed_size,
13551                              dwarf_size_type *  size)
13552 {
13553   dwarf_size_type compressed_size = *size;
13554   unsigned char * compressed_buffer = *buffer;
13555   unsigned char * uncompressed_buffer;
13556   z_stream strm;
13557   int rc;
13558
13559   /* It is possible the section consists of several compressed
13560      buffers concatenated together, so we uncompress in a loop.  */
13561   /* PR 18313: The state field in the z_stream structure is supposed
13562      to be invisible to the user (ie us), but some compilers will
13563      still complain about it being used without initialisation.  So
13564      we first zero the entire z_stream structure and then set the fields
13565      that we need.  */
13566   memset (& strm, 0, sizeof strm);
13567   strm.avail_in = compressed_size;
13568   strm.next_in = (Bytef *) compressed_buffer;
13569   strm.avail_out = uncompressed_size;
13570   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13571
13572   rc = inflateInit (& strm);
13573   while (strm.avail_in > 0)
13574     {
13575       if (rc != Z_OK)
13576         goto fail;
13577       strm.next_out = ((Bytef *) uncompressed_buffer
13578                        + (uncompressed_size - strm.avail_out));
13579       rc = inflate (&strm, Z_FINISH);
13580       if (rc != Z_STREAM_END)
13581         goto fail;
13582       rc = inflateReset (& strm);
13583     }
13584   rc = inflateEnd (& strm);
13585   if (rc != Z_OK
13586       || strm.avail_out != 0)
13587     goto fail;
13588
13589   *buffer = uncompressed_buffer;
13590   *size = uncompressed_size;
13591   return TRUE;
13592
13593  fail:
13594   free (uncompressed_buffer);
13595   /* Indicate decompression failure.  */
13596   *buffer = NULL;
13597   return FALSE;
13598 }
13599
13600 static bfd_boolean
13601 dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13602 {
13603   Elf_Internal_Shdr *  relsec;
13604   bfd_size_type        num_bytes;
13605   unsigned char *      data;
13606   unsigned char *      end;
13607   unsigned char *      real_start;
13608   unsigned char *      start;
13609   bfd_boolean          some_strings_shown;
13610
13611   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13612   if (start == NULL)
13613     /* PR 21820: Do not fail if the section was empty.  */
13614     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13615
13616   num_bytes = section->sh_size;
13617
13618   printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13619
13620   if (decompress_dumps)
13621     {
13622       dwarf_size_type new_size = num_bytes;
13623       dwarf_size_type uncompressed_size = 0;
13624
13625       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13626         {
13627           Elf_Internal_Chdr chdr;
13628           unsigned int compression_header_size
13629             = get_compression_header (& chdr, (unsigned char *) start,
13630                                       num_bytes);
13631
13632           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13633             {
13634               warn (_("section '%s' has unsupported compress type: %d\n"),
13635                     printable_section_name (filedata, section), chdr.ch_type);
13636               return FALSE;
13637             }
13638           uncompressed_size = chdr.ch_size;
13639           start += compression_header_size;
13640           new_size -= compression_header_size;
13641         }
13642       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13643         {
13644           /* Read the zlib header.  In this case, it should be "ZLIB"
13645              followed by the uncompressed section size, 8 bytes in
13646              big-endian order.  */
13647           uncompressed_size = start[4]; uncompressed_size <<= 8;
13648           uncompressed_size += start[5]; uncompressed_size <<= 8;
13649           uncompressed_size += start[6]; uncompressed_size <<= 8;
13650           uncompressed_size += start[7]; uncompressed_size <<= 8;
13651           uncompressed_size += start[8]; uncompressed_size <<= 8;
13652           uncompressed_size += start[9]; uncompressed_size <<= 8;
13653           uncompressed_size += start[10]; uncompressed_size <<= 8;
13654           uncompressed_size += start[11];
13655           start += 12;
13656           new_size -= 12;
13657         }
13658
13659       if (uncompressed_size)
13660         {
13661           if (uncompress_section_contents (& start,
13662                                            uncompressed_size, & new_size))
13663             num_bytes = new_size;
13664           else
13665             {
13666               error (_("Unable to decompress section %s\n"),
13667                      printable_section_name (filedata, section));
13668               return FALSE;
13669             }
13670         }
13671       else
13672         start = real_start;
13673     }
13674
13675   /* If the section being dumped has relocations against it the user might
13676      be expecting these relocations to have been applied.  Check for this
13677      case and issue a warning message in order to avoid confusion.
13678      FIXME: Maybe we ought to have an option that dumps a section with
13679      relocs applied ?  */
13680   for (relsec = filedata->section_headers;
13681        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13682        ++relsec)
13683     {
13684       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13685           || relsec->sh_info >= filedata->file_header.e_shnum
13686           || filedata->section_headers + relsec->sh_info != section
13687           || relsec->sh_size == 0
13688           || relsec->sh_link >= filedata->file_header.e_shnum)
13689         continue;
13690
13691       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13692       break;
13693     }
13694
13695   data = start;
13696   end  = start + num_bytes;
13697   some_strings_shown = FALSE;
13698
13699   while (data < end)
13700     {
13701       while (!ISPRINT (* data))
13702         if (++ data >= end)
13703           break;
13704
13705       if (data < end)
13706         {
13707           size_t maxlen = end - data;
13708
13709 #ifndef __MSVCRT__
13710           /* PR 11128: Use two separate invocations in order to work
13711              around bugs in the Solaris 8 implementation of printf.  */
13712           printf ("  [%6tx]  ", data - start);
13713 #else
13714           printf ("  [%6Ix]  ", (size_t) (data - start));
13715 #endif
13716           if (maxlen > 0)
13717             {
13718               print_symbol ((int) maxlen, (const char *) data);
13719               putchar ('\n');
13720               data += strnlen ((const char *) data, maxlen);
13721             }
13722           else
13723             {
13724               printf (_("<corrupt>\n"));
13725               data = end;
13726             }
13727           some_strings_shown = TRUE;
13728         }
13729     }
13730
13731   if (! some_strings_shown)
13732     printf (_("  No strings found in this section."));
13733
13734   free (real_start);
13735
13736   putchar ('\n');
13737   return TRUE;
13738 }
13739
13740 static bfd_boolean
13741 dump_section_as_bytes (Elf_Internal_Shdr *  section,
13742                        Filedata *           filedata,
13743                        bfd_boolean          relocate)
13744 {
13745   Elf_Internal_Shdr * relsec;
13746   bfd_size_type       bytes;
13747   bfd_size_type       section_size;
13748   bfd_vma             addr;
13749   unsigned char *     data;
13750   unsigned char *     real_start;
13751   unsigned char *     start;
13752
13753   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13754   if (start == NULL)
13755     /* PR 21820: Do not fail if the section was empty.  */
13756     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13757
13758   section_size = section->sh_size;
13759
13760   printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13761
13762   if (decompress_dumps)
13763     {
13764       dwarf_size_type new_size = section_size;
13765       dwarf_size_type uncompressed_size = 0;
13766
13767       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13768         {
13769           Elf_Internal_Chdr chdr;
13770           unsigned int compression_header_size
13771             = get_compression_header (& chdr, start, section_size);
13772
13773           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13774             {
13775               warn (_("section '%s' has unsupported compress type: %d\n"),
13776                     printable_section_name (filedata, section), chdr.ch_type);
13777               return FALSE;
13778             }
13779           uncompressed_size = chdr.ch_size;
13780           start += compression_header_size;
13781           new_size -= compression_header_size;
13782         }
13783       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13784         {
13785           /* Read the zlib header.  In this case, it should be "ZLIB"
13786              followed by the uncompressed section size, 8 bytes in
13787              big-endian order.  */
13788           uncompressed_size = start[4]; uncompressed_size <<= 8;
13789           uncompressed_size += start[5]; uncompressed_size <<= 8;
13790           uncompressed_size += start[6]; uncompressed_size <<= 8;
13791           uncompressed_size += start[7]; uncompressed_size <<= 8;
13792           uncompressed_size += start[8]; uncompressed_size <<= 8;
13793           uncompressed_size += start[9]; uncompressed_size <<= 8;
13794           uncompressed_size += start[10]; uncompressed_size <<= 8;
13795           uncompressed_size += start[11];
13796           start += 12;
13797           new_size -= 12;
13798         }
13799
13800       if (uncompressed_size)
13801         {
13802           if (uncompress_section_contents (& start, uncompressed_size,
13803                                            & new_size))
13804             {
13805               section_size = new_size;
13806             }
13807           else
13808             {
13809               error (_("Unable to decompress section %s\n"),
13810                      printable_section_name (filedata, section));
13811               /* FIXME: Print the section anyway ?  */
13812               return FALSE;
13813             }
13814         }
13815       else
13816         start = real_start;
13817     }
13818
13819   if (relocate)
13820     {
13821       if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
13822         return FALSE;
13823     }
13824   else
13825     {
13826       /* If the section being dumped has relocations against it the user might
13827          be expecting these relocations to have been applied.  Check for this
13828          case and issue a warning message in order to avoid confusion.
13829          FIXME: Maybe we ought to have an option that dumps a section with
13830          relocs applied ?  */
13831       for (relsec = filedata->section_headers;
13832            relsec < filedata->section_headers + filedata->file_header.e_shnum;
13833            ++relsec)
13834         {
13835           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13836               || relsec->sh_info >= filedata->file_header.e_shnum
13837               || filedata->section_headers + relsec->sh_info != section
13838               || relsec->sh_size == 0
13839               || relsec->sh_link >= filedata->file_header.e_shnum)
13840             continue;
13841
13842           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13843           break;
13844         }
13845     }
13846
13847   addr = section->sh_addr;
13848   bytes = section_size;
13849   data = start;
13850
13851   while (bytes)
13852     {
13853       int j;
13854       int k;
13855       int lbytes;
13856
13857       lbytes = (bytes > 16 ? 16 : bytes);
13858
13859       printf ("  0x%8.8lx ", (unsigned long) addr);
13860
13861       for (j = 0; j < 16; j++)
13862         {
13863           if (j < lbytes)
13864             printf ("%2.2x", data[j]);
13865           else
13866             printf ("  ");
13867
13868           if ((j & 3) == 3)
13869             printf (" ");
13870         }
13871
13872       for (j = 0; j < lbytes; j++)
13873         {
13874           k = data[j];
13875           if (k >= ' ' && k < 0x7f)
13876             printf ("%c", k);
13877           else
13878             printf (".");
13879         }
13880
13881       putchar ('\n');
13882
13883       data  += lbytes;
13884       addr  += lbytes;
13885       bytes -= lbytes;
13886     }
13887
13888   free (real_start);
13889
13890   putchar ('\n');
13891   return TRUE;
13892 }
13893
13894 static ctf_sect_t *
13895 shdr_to_ctf_sect (ctf_sect_t *buf, Elf_Internal_Shdr *shdr, Filedata *filedata)
13896 {
13897   buf->cts_name = SECTION_NAME (shdr);
13898   buf->cts_size = shdr->sh_size;
13899   buf->cts_entsize = shdr->sh_entsize;
13900
13901   return buf;
13902 }
13903
13904 /* Formatting callback function passed to ctf_dump.  Returns either the pointer
13905    it is passed, or a pointer to newly-allocated storage, in which case
13906    dump_ctf() will free it when it no longer needs it.  */
13907
13908 static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED,
13909                                     char *s, void *arg)
13910 {
13911   const char *blanks = arg;
13912   char *new_s;
13913
13914   if (asprintf (&new_s, "%s%s", blanks, s) < 0)
13915     return s;
13916   return new_s;
13917 }
13918
13919 static bfd_boolean
13920 dump_section_as_ctf (Elf_Internal_Shdr * section, Filedata * filedata)
13921 {
13922   Elf_Internal_Shdr *  parent_sec = NULL;
13923   Elf_Internal_Shdr *  symtab_sec = NULL;
13924   Elf_Internal_Shdr *  strtab_sec = NULL;
13925   void *               data = NULL;
13926   void *               symdata = NULL;
13927   void *               strdata = NULL;
13928   void *               parentdata = NULL;
13929   ctf_sect_t           ctfsect, symsect, strsect, parentsect;
13930   ctf_sect_t *         symsectp = NULL;
13931   ctf_sect_t *         strsectp = NULL;
13932   ctf_file_t *         ctf = NULL;
13933   ctf_file_t *         parent = NULL;
13934
13935   const char *things[] = {"Labels", "Data objects", "Function objects",
13936                           "Variables", "Types", "Strings", ""};
13937   const char **thing;
13938   int err;
13939   bfd_boolean ret = FALSE;
13940   size_t i;
13941
13942   shdr_to_ctf_sect (&ctfsect, section, filedata);
13943   data = get_section_contents (section, filedata);
13944   ctfsect.cts_data = data;
13945
13946   if (dump_ctf_symtab_name)
13947     {
13948       if ((symtab_sec = find_section (filedata, dump_ctf_symtab_name)) == NULL)
13949         {
13950           error (_("No symbol section named %s\n"), dump_ctf_symtab_name);
13951           goto fail;
13952         }
13953       if ((symdata = (void *) get_data (NULL, filedata,
13954                                         symtab_sec->sh_offset, 1,
13955                                         symtab_sec->sh_size,
13956                                         _("symbols"))) == NULL)
13957         goto fail;
13958       symsectp = shdr_to_ctf_sect (&symsect, symtab_sec, filedata);
13959       symsect.cts_data = symdata;
13960     }
13961   if (dump_ctf_strtab_name)
13962     {
13963       if ((strtab_sec = find_section (filedata, dump_ctf_strtab_name)) == NULL)
13964         {
13965           error (_("No string table section named %s\n"),
13966                  dump_ctf_strtab_name);
13967           goto fail;
13968         }
13969       if ((strdata = (void *) get_data (NULL, filedata,
13970                                         strtab_sec->sh_offset, 1,
13971                                         strtab_sec->sh_size,
13972                                         _("strings"))) == NULL)
13973         goto fail;
13974       strsectp = shdr_to_ctf_sect (&strsect, strtab_sec, filedata);
13975       strsect.cts_data = strdata;
13976     }
13977   if (dump_ctf_parent_name)
13978     {
13979       if ((parent_sec = find_section (filedata, dump_ctf_parent_name)) == NULL)
13980         {
13981           error (_("No CTF parent section named %s\n"), dump_ctf_parent_name);
13982           goto fail;
13983         }
13984       if ((parentdata = (void *) get_data (NULL, filedata,
13985                                            parent_sec->sh_offset, 1,
13986                                            parent_sec->sh_size,
13987                                            _("CTF parent"))) == NULL)
13988         goto fail;
13989       shdr_to_ctf_sect (&parentsect, parent_sec, filedata);
13990       parentsect.cts_data = parentdata;
13991     }
13992
13993   /* Load the CTF file and dump it.  */
13994
13995   if ((ctf = ctf_bufopen (&ctfsect, symsectp, strsectp, &err)) == NULL)
13996     {
13997       error (_("CTF open failure: %s\n"), ctf_errmsg (err));
13998       goto fail;
13999     }
14000
14001   if (parentdata)
14002     {
14003       if ((parent = ctf_bufopen (&parentsect, symsectp, strsectp, &err)) == NULL)
14004         {
14005           error (_("CTF open failure: %s\n"), ctf_errmsg (err));
14006           goto fail;
14007         }
14008
14009       ctf_import (ctf, parent);
14010     }
14011
14012   ret = TRUE;
14013
14014   printf (_("\nDump of CTF section '%s':\n"),
14015           printable_section_name (filedata, section));
14016
14017   for (i = 1, thing = things; *thing[0]; thing++, i++)
14018     {
14019       ctf_dump_state_t *s = NULL;
14020       char *item;
14021
14022       printf ("\n  %s:\n", *thing);
14023       while ((item = ctf_dump (ctf, &s, i, dump_ctf_indent_lines,
14024                                (void *) "    ")) != NULL)
14025         {
14026           printf ("%s\n", item);
14027           free (item);
14028         }
14029
14030       if (ctf_errno (ctf))
14031         {
14032           error (_("Iteration failed: %s, %s\n"), *thing,
14033                    ctf_errmsg (ctf_errno (ctf)));
14034           ret = FALSE;
14035         }
14036     }
14037
14038  fail:
14039   ctf_file_close (ctf);
14040   ctf_file_close (parent);
14041   free (parentdata);
14042   free (data);
14043   free (symdata);
14044   free (strdata);
14045   return ret;
14046 }
14047
14048 static bfd_boolean
14049 load_specific_debug_section (enum dwarf_section_display_enum  debug,
14050                              const Elf_Internal_Shdr *        sec,
14051                              void *                           data)
14052 {
14053   struct dwarf_section * section = &debug_displays [debug].section;
14054   char buf [64];
14055   Filedata * filedata = (Filedata *) data;
14056
14057   if (section->start != NULL)
14058     {
14059       /* If it is already loaded, do nothing.  */
14060       if (streq (section->filename, filedata->file_name))
14061         return TRUE;
14062       free (section->start);
14063     }
14064
14065   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
14066   section->address = sec->sh_addr;
14067   section->user_data = NULL;
14068   section->filename = filedata->file_name;
14069   section->start = (unsigned char *) get_data (NULL, filedata,
14070                                                sec->sh_offset, 1,
14071                                                sec->sh_size, buf);
14072   if (section->start == NULL)
14073     section->size = 0;
14074   else
14075     {
14076       unsigned char *start = section->start;
14077       dwarf_size_type size = sec->sh_size;
14078       dwarf_size_type uncompressed_size = 0;
14079
14080       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
14081         {
14082           Elf_Internal_Chdr chdr;
14083           unsigned int compression_header_size;
14084
14085           if (size < (is_32bit_elf
14086                       ? sizeof (Elf32_External_Chdr)
14087                       : sizeof (Elf64_External_Chdr)))
14088             {
14089               warn (_("compressed section %s is too small to contain a compression header"),
14090                     section->name);
14091               return FALSE;
14092             }
14093
14094           compression_header_size = get_compression_header (&chdr, start, size);
14095
14096           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
14097             {
14098               warn (_("section '%s' has unsupported compress type: %d\n"),
14099                     section->name, chdr.ch_type);
14100               return FALSE;
14101             }
14102           uncompressed_size = chdr.ch_size;
14103           start += compression_header_size;
14104           size -= compression_header_size;
14105         }
14106       else if (size > 12 && streq ((char *) start, "ZLIB"))
14107         {
14108           /* Read the zlib header.  In this case, it should be "ZLIB"
14109              followed by the uncompressed section size, 8 bytes in
14110              big-endian order.  */
14111           uncompressed_size = start[4]; uncompressed_size <<= 8;
14112           uncompressed_size += start[5]; uncompressed_size <<= 8;
14113           uncompressed_size += start[6]; uncompressed_size <<= 8;
14114           uncompressed_size += start[7]; uncompressed_size <<= 8;
14115           uncompressed_size += start[8]; uncompressed_size <<= 8;
14116           uncompressed_size += start[9]; uncompressed_size <<= 8;
14117           uncompressed_size += start[10]; uncompressed_size <<= 8;
14118           uncompressed_size += start[11];
14119           start += 12;
14120           size -= 12;
14121         }
14122
14123       if (uncompressed_size)
14124         {
14125           if (uncompress_section_contents (&start, uncompressed_size,
14126                                            &size))
14127             {
14128               /* Free the compressed buffer, update the section buffer
14129                  and the section size if uncompress is successful.  */
14130               free (section->start);
14131               section->start = start;
14132             }
14133           else
14134             {
14135               error (_("Unable to decompress section %s\n"),
14136                      printable_section_name (filedata, sec));
14137               return FALSE;
14138             }
14139         }
14140
14141       section->size = size;
14142     }
14143
14144   if (section->start == NULL)
14145     return FALSE;
14146
14147   if (debug_displays [debug].relocate)
14148     {
14149       if (! apply_relocations (filedata, sec, section->start, section->size,
14150                                & section->reloc_info, & section->num_relocs))
14151         return FALSE;
14152     }
14153   else
14154     {
14155       section->reloc_info = NULL;
14156       section->num_relocs = 0;
14157     }
14158
14159   return TRUE;
14160 }
14161
14162 /* If this is not NULL, load_debug_section will only look for sections
14163    within the list of sections given here.  */
14164 static unsigned int * section_subset = NULL;
14165
14166 bfd_boolean
14167 load_debug_section (enum dwarf_section_display_enum debug, void * data)
14168 {
14169   struct dwarf_section * section = &debug_displays [debug].section;
14170   Elf_Internal_Shdr * sec;
14171   Filedata * filedata = (Filedata *) data;
14172
14173   /* Without section headers we cannot find any sections.  */
14174   if (filedata->section_headers == NULL)
14175     return FALSE;
14176
14177   if (filedata->string_table == NULL
14178       && filedata->file_header.e_shstrndx != SHN_UNDEF
14179       && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
14180     {
14181       Elf_Internal_Shdr * strs;
14182
14183       /* Read in the string table, so that we have section names to scan.  */
14184       strs = filedata->section_headers + filedata->file_header.e_shstrndx;
14185
14186       if (strs != NULL && strs->sh_size != 0)
14187         {
14188           filedata->string_table
14189             = (char *) get_data (NULL, filedata, strs->sh_offset,
14190                                  1, strs->sh_size, _("string table"));
14191
14192           filedata->string_table_length
14193             = filedata->string_table != NULL ? strs->sh_size : 0;
14194         }
14195     }
14196
14197   /* Locate the debug section.  */
14198   sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
14199   if (sec != NULL)
14200     section->name = section->uncompressed_name;
14201   else
14202     {
14203       sec = find_section_in_set (filedata, section->compressed_name, section_subset);
14204       if (sec != NULL)
14205         section->name = section->compressed_name;
14206     }
14207   if (sec == NULL)
14208     return FALSE;
14209
14210   /* If we're loading from a subset of sections, and we've loaded
14211      a section matching this name before, it's likely that it's a
14212      different one.  */
14213   if (section_subset != NULL)
14214     free_debug_section (debug);
14215
14216   return load_specific_debug_section (debug, sec, data);
14217 }
14218
14219 void
14220 free_debug_section (enum dwarf_section_display_enum debug)
14221 {
14222   struct dwarf_section * section = &debug_displays [debug].section;
14223
14224   if (section->start == NULL)
14225     return;
14226
14227   free ((char *) section->start);
14228   section->start = NULL;
14229   section->address = 0;
14230   section->size = 0;
14231 }
14232
14233 static bfd_boolean
14234 display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
14235 {
14236   char * name = SECTION_NAME (section);
14237   const char * print_name = printable_section_name (filedata, section);
14238   bfd_size_type length;
14239   bfd_boolean result = TRUE;
14240   int i;
14241
14242   length = section->sh_size;
14243   if (length == 0)
14244     {
14245       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
14246       return TRUE;
14247     }
14248   if (section->sh_type == SHT_NOBITS)
14249     {
14250       /* There is no point in dumping the contents of a debugging section
14251          which has the NOBITS type - the bits in the file will be random.
14252          This can happen when a file containing a .eh_frame section is
14253          stripped with the --only-keep-debug command line option.  */
14254       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14255               print_name);
14256       return FALSE;
14257     }
14258
14259   if (const_strneq (name, ".gnu.linkonce.wi."))
14260     name = ".debug_info";
14261
14262   /* See if we know how to display the contents of this section.  */
14263   for (i = 0; i < max; i++)
14264     {
14265       enum dwarf_section_display_enum  id = (enum dwarf_section_display_enum) i;
14266       struct dwarf_section_display *   display = debug_displays + i;
14267       struct dwarf_section *           sec = & display->section;
14268
14269       if (streq (sec->uncompressed_name, name)
14270           || (id == line && const_strneq (name, ".debug_line."))
14271           || streq (sec->compressed_name, name))
14272         {
14273           bfd_boolean secondary = (section != find_section (filedata, name));
14274
14275           if (secondary)
14276             free_debug_section (id);
14277
14278           if (i == line && const_strneq (name, ".debug_line."))
14279             sec->name = name;
14280           else if (streq (sec->uncompressed_name, name))
14281             sec->name = sec->uncompressed_name;
14282           else
14283             sec->name = sec->compressed_name;
14284
14285           if (load_specific_debug_section (id, section, filedata))
14286             {
14287               /* If this debug section is part of a CU/TU set in a .dwp file,
14288                  restrict load_debug_section to the sections in that set.  */
14289               section_subset = find_cu_tu_set (filedata, shndx);
14290
14291               result &= display->display (sec, filedata);
14292
14293               section_subset = NULL;
14294
14295               if (secondary || (id != info && id != abbrev))
14296                 free_debug_section (id);
14297             }
14298           break;
14299         }
14300     }
14301
14302   if (i == max)
14303     {
14304       printf (_("Unrecognized debug section: %s\n"), print_name);
14305       result = FALSE;
14306     }
14307
14308   return result;
14309 }
14310
14311 /* Set DUMP_SECTS for all sections where dumps were requested
14312    based on section name.  */
14313
14314 static void
14315 initialise_dumps_byname (Filedata * filedata)
14316 {
14317   struct dump_list_entry * cur;
14318
14319   for (cur = dump_sects_byname; cur; cur = cur->next)
14320     {
14321       unsigned int i;
14322       bfd_boolean any = FALSE;
14323
14324       for (i = 0; i < filedata->file_header.e_shnum; i++)
14325         if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
14326           {
14327             request_dump_bynumber (filedata, i, cur->type);
14328             any = TRUE;
14329           }
14330
14331       if (!any)
14332         warn (_("Section '%s' was not dumped because it does not exist!\n"),
14333               cur->name);
14334     }
14335 }
14336
14337 static bfd_boolean
14338 process_section_contents (Filedata * filedata)
14339 {
14340   Elf_Internal_Shdr * section;
14341   unsigned int i;
14342   bfd_boolean res = TRUE;
14343
14344   if (! do_dump)
14345     return TRUE;
14346
14347   initialise_dumps_byname (filedata);
14348
14349   for (i = 0, section = filedata->section_headers;
14350        i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
14351        i++, section++)
14352     {
14353       dump_type dump = filedata->dump_sects[i];
14354
14355 #ifdef SUPPORT_DISASSEMBLY
14356       if (dump & DISASS_DUMP)
14357         {
14358           if (! disassemble_section (section, filedata))
14359             res = FALSE;
14360         }
14361 #endif
14362       if (dump & HEX_DUMP)
14363         {
14364           if (! dump_section_as_bytes (section, filedata, FALSE))
14365             res = FALSE;
14366         }
14367
14368       if (dump & RELOC_DUMP)
14369         {
14370           if (! dump_section_as_bytes (section, filedata, TRUE))
14371             res = FALSE;
14372         }
14373
14374       if (dump & STRING_DUMP)
14375         {
14376           if (! dump_section_as_strings (section, filedata))
14377             res = FALSE;
14378         }
14379
14380       if (dump & DEBUG_DUMP)
14381         {
14382           if (! display_debug_section (i, section, filedata))
14383             res = FALSE;
14384         }
14385
14386       if (dump & CTF_DUMP)
14387         {
14388           if (! dump_section_as_ctf (section, filedata))
14389             res = FALSE;
14390         }
14391     }
14392
14393   /* Check to see if the user requested a
14394      dump of a section that does not exist.  */
14395   while (i < filedata->num_dump_sects)
14396     {
14397       if (filedata->dump_sects[i])
14398         {
14399           warn (_("Section %d was not dumped because it does not exist!\n"), i);
14400           res = FALSE;
14401         }
14402       i++;
14403     }
14404
14405   return res;
14406 }
14407
14408 static void
14409 process_mips_fpe_exception (int mask)
14410 {
14411   if (mask)
14412     {
14413       bfd_boolean first = TRUE;
14414
14415       if (mask & OEX_FPU_INEX)
14416         fputs ("INEX", stdout), first = FALSE;
14417       if (mask & OEX_FPU_UFLO)
14418         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
14419       if (mask & OEX_FPU_OFLO)
14420         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
14421       if (mask & OEX_FPU_DIV0)
14422         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
14423       if (mask & OEX_FPU_INVAL)
14424         printf ("%sINVAL", first ? "" : "|");
14425     }
14426   else
14427     fputs ("0", stdout);
14428 }
14429
14430 /* Display's the value of TAG at location P.  If TAG is
14431    greater than 0 it is assumed to be an unknown tag, and
14432    a message is printed to this effect.  Otherwise it is
14433    assumed that a message has already been printed.
14434
14435    If the bottom bit of TAG is set it assumed to have a
14436    string value, otherwise it is assumed to have an integer
14437    value.
14438
14439    Returns an updated P pointing to the first unread byte
14440    beyond the end of TAG's value.
14441
14442    Reads at or beyond END will not be made.  */
14443
14444 static unsigned char *
14445 display_tag_value (signed int tag,
14446                    unsigned char * p,
14447                    const unsigned char * const end)
14448 {
14449   unsigned long val;
14450
14451   if (tag > 0)
14452     printf ("  Tag_unknown_%d: ", tag);
14453
14454   if (p >= end)
14455     {
14456       warn (_("<corrupt tag>\n"));
14457     }
14458   else if (tag & 1)
14459     {
14460       /* PR 17531 file: 027-19978-0.004.  */
14461       size_t maxlen = (end - p) - 1;
14462
14463       putchar ('"');
14464       if (maxlen > 0)
14465         {
14466           print_symbol ((int) maxlen, (const char *) p);
14467           p += strnlen ((char *) p, maxlen) + 1;
14468         }
14469       else
14470         {
14471           printf (_("<corrupt string tag>"));
14472           p = (unsigned char *) end;
14473         }
14474       printf ("\"\n");
14475     }
14476   else
14477     {
14478       unsigned int len;
14479
14480       val = read_uleb128 (p, &len, end);
14481       p += len;
14482       printf ("%ld (0x%lx)\n", val, val);
14483     }
14484
14485   assert (p <= end);
14486   return p;
14487 }
14488
14489 /* ARC ABI attributes section.  */
14490
14491 static unsigned char *
14492 display_arc_attribute (unsigned char * p,
14493                        const unsigned char * const end)
14494 {
14495   unsigned int tag;
14496   unsigned int len;
14497   unsigned int val;
14498
14499   tag = read_uleb128 (p, &len, end);
14500   p += len;
14501
14502   switch (tag)
14503     {
14504     case Tag_ARC_PCS_config:
14505       val = read_uleb128 (p, &len, end);
14506       p += len;
14507       printf ("  Tag_ARC_PCS_config: ");
14508       switch (val)
14509         {
14510         case 0:
14511           printf (_("Absent/Non standard\n"));
14512           break;
14513         case 1:
14514           printf (_("Bare metal/mwdt\n"));
14515           break;
14516         case 2:
14517           printf (_("Bare metal/newlib\n"));
14518           break;
14519         case 3:
14520           printf (_("Linux/uclibc\n"));
14521           break;
14522         case 4:
14523           printf (_("Linux/glibc\n"));
14524           break;
14525         default:
14526           printf (_("Unknown\n"));
14527           break;
14528         }
14529       break;
14530
14531     case Tag_ARC_CPU_base:
14532       val = read_uleb128 (p, &len, end);
14533       p += len;
14534       printf ("  Tag_ARC_CPU_base: ");
14535       switch (val)
14536         {
14537         default:
14538         case TAG_CPU_NONE:
14539           printf (_("Absent\n"));
14540           break;
14541         case TAG_CPU_ARC6xx:
14542           printf ("ARC6xx\n");
14543           break;
14544         case TAG_CPU_ARC7xx:
14545           printf ("ARC7xx\n");
14546           break;
14547         case TAG_CPU_ARCEM:
14548           printf ("ARCEM\n");
14549           break;
14550         case TAG_CPU_ARCHS:
14551           printf ("ARCHS\n");
14552           break;
14553         }
14554       break;
14555
14556     case Tag_ARC_CPU_variation:
14557       val = read_uleb128 (p, &len, end);
14558       p += len;
14559       printf ("  Tag_ARC_CPU_variation: ");
14560       switch (val)
14561         {
14562         default:
14563           if (val > 0 && val < 16)
14564               printf ("Core%d\n", val);
14565           else
14566               printf ("Unknown\n");
14567           break;
14568
14569         case 0:
14570           printf (_("Absent\n"));
14571           break;
14572         }
14573       break;
14574
14575     case Tag_ARC_CPU_name:
14576       printf ("  Tag_ARC_CPU_name: ");
14577       p = display_tag_value (-1, p, end);
14578       break;
14579
14580     case Tag_ARC_ABI_rf16:
14581       val = read_uleb128 (p, &len, end);
14582       p += len;
14583       printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
14584       break;
14585
14586     case Tag_ARC_ABI_osver:
14587       val = read_uleb128 (p, &len, end);
14588       p += len;
14589       printf ("  Tag_ARC_ABI_osver: v%d\n", val);
14590       break;
14591
14592     case Tag_ARC_ABI_pic:
14593     case Tag_ARC_ABI_sda:
14594       val = read_uleb128 (p, &len, end);
14595       p += len;
14596       printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
14597               : "  Tag_ARC_ABI_pic: ");
14598       switch (val)
14599         {
14600         case 0:
14601           printf (_("Absent\n"));
14602           break;
14603         case 1:
14604           printf ("MWDT\n");
14605           break;
14606         case 2:
14607           printf ("GNU\n");
14608           break;
14609         default:
14610           printf (_("Unknown\n"));
14611           break;
14612         }
14613       break;
14614
14615     case Tag_ARC_ABI_tls:
14616       val = read_uleb128 (p, &len, end);
14617       p += len;
14618       printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14619       break;
14620
14621     case Tag_ARC_ABI_enumsize:
14622       val = read_uleb128 (p, &len, end);
14623       p += len;
14624       printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14625               _("smallest"));
14626       break;
14627
14628     case Tag_ARC_ABI_exceptions:
14629       val = read_uleb128 (p, &len, end);
14630       p += len;
14631       printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14632               : _("default"));
14633       break;
14634
14635     case Tag_ARC_ABI_double_size:
14636       val = read_uleb128 (p, &len, end);
14637       p += len;
14638       printf ("  Tag_ARC_ABI_double_size: %d\n", val);
14639       break;
14640
14641     case Tag_ARC_ISA_config:
14642       printf ("  Tag_ARC_ISA_config: ");
14643       p = display_tag_value (-1, p, end);
14644       break;
14645
14646     case Tag_ARC_ISA_apex:
14647       printf ("  Tag_ARC_ISA_apex: ");
14648       p = display_tag_value (-1, p, end);
14649       break;
14650
14651     case Tag_ARC_ISA_mpy_option:
14652       val = read_uleb128 (p, &len, end);
14653       p += len;
14654       printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
14655       break;
14656
14657     case Tag_ARC_ATR_version:
14658       val = read_uleb128 (p, &len, end);
14659       p += len;
14660       printf ("  Tag_ARC_ATR_version: %d\n", val);
14661       break;
14662
14663     default:
14664       return display_tag_value (tag & 1, p, end);
14665     }
14666
14667   return p;
14668 }
14669
14670 /* ARM EABI attributes section.  */
14671 typedef struct
14672 {
14673   unsigned int tag;
14674   const char * name;
14675   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
14676   unsigned int type;
14677   const char ** table;
14678 } arm_attr_public_tag;
14679
14680 static const char * arm_attr_tag_CPU_arch[] =
14681   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14682    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14683    "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
14684 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14685 static const char * arm_attr_tag_THUMB_ISA_use[] =
14686   {"No", "Thumb-1", "Thumb-2", "Yes"};
14687 static const char * arm_attr_tag_FP_arch[] =
14688   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14689    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14690 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14691 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14692   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14693    "NEON for ARMv8.1"};
14694 static const char * arm_attr_tag_PCS_config[] =
14695   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14696    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14697 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14698   {"V6", "SB", "TLS", "Unused"};
14699 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14700   {"Absolute", "PC-relative", "SB-relative", "None"};
14701 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14702   {"Absolute", "PC-relative", "None"};
14703 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14704   {"None", "direct", "GOT-indirect"};
14705 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14706   {"None", "??? 1", "2", "??? 3", "4"};
14707 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14708 static const char * arm_attr_tag_ABI_FP_denormal[] =
14709   {"Unused", "Needed", "Sign only"};
14710 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14711 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14712 static const char * arm_attr_tag_ABI_FP_number_model[] =
14713   {"Unused", "Finite", "RTABI", "IEEE 754"};
14714 static const char * arm_attr_tag_ABI_enum_size[] =
14715   {"Unused", "small", "int", "forced to int"};
14716 static const char * arm_attr_tag_ABI_HardFP_use[] =
14717   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14718 static const char * arm_attr_tag_ABI_VFP_args[] =
14719   {"AAPCS", "VFP registers", "custom", "compatible"};
14720 static const char * arm_attr_tag_ABI_WMMX_args[] =
14721   {"AAPCS", "WMMX registers", "custom"};
14722 static const char * arm_attr_tag_ABI_optimization_goals[] =
14723   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14724     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14725 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14726   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14727     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14728 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14729 static const char * arm_attr_tag_FP_HP_extension[] =
14730   {"Not Allowed", "Allowed"};
14731 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14732   {"None", "IEEE 754", "Alternative Format"};
14733 static const char * arm_attr_tag_DSP_extension[] =
14734   {"Follow architecture", "Allowed"};
14735 static const char * arm_attr_tag_MPextension_use[] =
14736   {"Not Allowed", "Allowed"};
14737 static const char * arm_attr_tag_DIV_use[] =
14738   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14739     "Allowed in v7-A with integer division extension"};
14740 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14741 static const char * arm_attr_tag_Virtualization_use[] =
14742   {"Not Allowed", "TrustZone", "Virtualization Extensions",
14743     "TrustZone and Virtualization Extensions"};
14744 static const char * arm_attr_tag_MPextension_use_legacy[] =
14745   {"Not Allowed", "Allowed"};
14746
14747 static const char * arm_attr_tag_MVE_arch[] =
14748   {"No MVE", "MVE Integer only", "MVE Integer and FP"};
14749
14750 #define LOOKUP(id, name) \
14751   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14752 static arm_attr_public_tag arm_attr_public_tags[] =
14753 {
14754   {4, "CPU_raw_name", 1, NULL},
14755   {5, "CPU_name", 1, NULL},
14756   LOOKUP(6, CPU_arch),
14757   {7, "CPU_arch_profile", 0, NULL},
14758   LOOKUP(8, ARM_ISA_use),
14759   LOOKUP(9, THUMB_ISA_use),
14760   LOOKUP(10, FP_arch),
14761   LOOKUP(11, WMMX_arch),
14762   LOOKUP(12, Advanced_SIMD_arch),
14763   LOOKUP(13, PCS_config),
14764   LOOKUP(14, ABI_PCS_R9_use),
14765   LOOKUP(15, ABI_PCS_RW_data),
14766   LOOKUP(16, ABI_PCS_RO_data),
14767   LOOKUP(17, ABI_PCS_GOT_use),
14768   LOOKUP(18, ABI_PCS_wchar_t),
14769   LOOKUP(19, ABI_FP_rounding),
14770   LOOKUP(20, ABI_FP_denormal),
14771   LOOKUP(21, ABI_FP_exceptions),
14772   LOOKUP(22, ABI_FP_user_exceptions),
14773   LOOKUP(23, ABI_FP_number_model),
14774   {24, "ABI_align_needed", 0, NULL},
14775   {25, "ABI_align_preserved", 0, NULL},
14776   LOOKUP(26, ABI_enum_size),
14777   LOOKUP(27, ABI_HardFP_use),
14778   LOOKUP(28, ABI_VFP_args),
14779   LOOKUP(29, ABI_WMMX_args),
14780   LOOKUP(30, ABI_optimization_goals),
14781   LOOKUP(31, ABI_FP_optimization_goals),
14782   {32, "compatibility", 0, NULL},
14783   LOOKUP(34, CPU_unaligned_access),
14784   LOOKUP(36, FP_HP_extension),
14785   LOOKUP(38, ABI_FP_16bit_format),
14786   LOOKUP(42, MPextension_use),
14787   LOOKUP(44, DIV_use),
14788   LOOKUP(46, DSP_extension),
14789   LOOKUP(48, MVE_arch),
14790   {64, "nodefaults", 0, NULL},
14791   {65, "also_compatible_with", 0, NULL},
14792   LOOKUP(66, T2EE_use),
14793   {67, "conformance", 1, NULL},
14794   LOOKUP(68, Virtualization_use),
14795   LOOKUP(70, MPextension_use_legacy)
14796 };
14797 #undef LOOKUP
14798
14799 static unsigned char *
14800 display_arm_attribute (unsigned char * p,
14801                        const unsigned char * const end)
14802 {
14803   unsigned int tag;
14804   unsigned int len;
14805   unsigned int val;
14806   arm_attr_public_tag * attr;
14807   unsigned i;
14808   unsigned int type;
14809
14810   tag = read_uleb128 (p, &len, end);
14811   p += len;
14812   attr = NULL;
14813   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14814     {
14815       if (arm_attr_public_tags[i].tag == tag)
14816         {
14817           attr = &arm_attr_public_tags[i];
14818           break;
14819         }
14820     }
14821
14822   if (attr)
14823     {
14824       printf ("  Tag_%s: ", attr->name);
14825       switch (attr->type)
14826         {
14827         case 0:
14828           switch (tag)
14829             {
14830             case 7: /* Tag_CPU_arch_profile.  */
14831               val = read_uleb128 (p, &len, end);
14832               p += len;
14833               switch (val)
14834                 {
14835                 case 0: printf (_("None\n")); break;
14836                 case 'A': printf (_("Application\n")); break;
14837                 case 'R': printf (_("Realtime\n")); break;
14838                 case 'M': printf (_("Microcontroller\n")); break;
14839                 case 'S': printf (_("Application or Realtime\n")); break;
14840                 default: printf ("??? (%d)\n", val); break;
14841                 }
14842               break;
14843
14844             case 24: /* Tag_align_needed.  */
14845               val = read_uleb128 (p, &len, end);
14846               p += len;
14847               switch (val)
14848                 {
14849                 case 0: printf (_("None\n")); break;
14850                 case 1: printf (_("8-byte\n")); break;
14851                 case 2: printf (_("4-byte\n")); break;
14852                 case 3: printf ("??? 3\n"); break;
14853                 default:
14854                   if (val <= 12)
14855                     printf (_("8-byte and up to %d-byte extended\n"),
14856                             1 << val);
14857                   else
14858                     printf ("??? (%d)\n", val);
14859                   break;
14860                 }
14861               break;
14862
14863             case 25: /* Tag_align_preserved.  */
14864               val = read_uleb128 (p, &len, end);
14865               p += len;
14866               switch (val)
14867                 {
14868                 case 0: printf (_("None\n")); break;
14869                 case 1: printf (_("8-byte, except leaf SP\n")); break;
14870                 case 2: printf (_("8-byte\n")); break;
14871                 case 3: printf ("??? 3\n"); break;
14872                 default:
14873                   if (val <= 12)
14874                     printf (_("8-byte and up to %d-byte extended\n"),
14875                             1 << val);
14876                   else
14877                     printf ("??? (%d)\n", val);
14878                   break;
14879                 }
14880               break;
14881
14882             case 32: /* Tag_compatibility.  */
14883               {
14884                 val = read_uleb128 (p, &len, end);
14885                 p += len;
14886                 printf (_("flag = %d, vendor = "), val);
14887                 if (p < end - 1)
14888                   {
14889                     size_t maxlen = (end - p) - 1;
14890
14891                     print_symbol ((int) maxlen, (const char *) p);
14892                     p += strnlen ((char *) p, maxlen) + 1;
14893                   }
14894                 else
14895                   {
14896                     printf (_("<corrupt>"));
14897                     p = (unsigned char *) end;
14898                   }
14899                 putchar ('\n');
14900               }
14901               break;
14902
14903             case 64: /* Tag_nodefaults.  */
14904               /* PR 17531: file: 001-505008-0.01.  */
14905               if (p < end)
14906                 p++;
14907               printf (_("True\n"));
14908               break;
14909
14910             case 65: /* Tag_also_compatible_with.  */
14911               val = read_uleb128 (p, &len, end);
14912               p += len;
14913               if (val == 6 /* Tag_CPU_arch.  */)
14914                 {
14915                   val = read_uleb128 (p, &len, end);
14916                   p += len;
14917                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14918                     printf ("??? (%d)\n", val);
14919                   else
14920                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14921                 }
14922               else
14923                 printf ("???\n");
14924               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
14925                 ;
14926               break;
14927
14928             default:
14929               printf (_("<unknown: %d>\n"), tag);
14930               break;
14931             }
14932           return p;
14933
14934         case 1:
14935           return display_tag_value (-1, p, end);
14936         case 2:
14937           return display_tag_value (0, p, end);
14938
14939         default:
14940           assert (attr->type & 0x80);
14941           val = read_uleb128 (p, &len, end);
14942           p += len;
14943           type = attr->type & 0x7f;
14944           if (val >= type)
14945             printf ("??? (%d)\n", val);
14946           else
14947             printf ("%s\n", attr->table[val]);
14948           return p;
14949         }
14950     }
14951
14952   return display_tag_value (tag, p, end);
14953 }
14954
14955 static unsigned char *
14956 display_gnu_attribute (unsigned char * p,
14957                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14958                        const unsigned char * const end)
14959 {
14960   int tag;
14961   unsigned int len;
14962   unsigned int val;
14963
14964   tag = read_uleb128 (p, &len, end);
14965   p += len;
14966
14967   /* Tag_compatibility is the only generic GNU attribute defined at
14968      present.  */
14969   if (tag == 32)
14970     {
14971       val = read_uleb128 (p, &len, end);
14972       p += len;
14973
14974       printf (_("flag = %d, vendor = "), val);
14975       if (p == end)
14976         {
14977           printf (_("<corrupt>\n"));
14978           warn (_("corrupt vendor attribute\n"));
14979         }
14980       else
14981         {
14982           if (p < end - 1)
14983             {
14984               size_t maxlen = (end - p) - 1;
14985
14986               print_symbol ((int) maxlen, (const char *) p);
14987               p += strnlen ((char *) p, maxlen) + 1;
14988             }
14989           else
14990             {
14991               printf (_("<corrupt>"));
14992               p = (unsigned char *) end;
14993             }
14994           putchar ('\n');
14995         }
14996       return p;
14997     }
14998
14999   if ((tag & 2) == 0 && display_proc_gnu_attribute)
15000     return display_proc_gnu_attribute (p, tag, end);
15001
15002   return display_tag_value (tag, p, end);
15003 }
15004
15005 static unsigned char *
15006 display_power_gnu_attribute (unsigned char * p,
15007                              unsigned int tag,
15008                              const unsigned char * const end)
15009 {
15010   unsigned int len;
15011   unsigned int val;
15012
15013   if (tag == Tag_GNU_Power_ABI_FP)
15014     {
15015       val = read_uleb128 (p, &len, end);
15016       p += len;
15017       printf ("  Tag_GNU_Power_ABI_FP: ");
15018       if (len == 0)
15019         {
15020           printf (_("<corrupt>\n"));
15021           return p;
15022         }
15023
15024       if (val > 15)
15025         printf ("(%#x), ", val);
15026
15027       switch (val & 3)
15028         {
15029         case 0:
15030           printf (_("unspecified hard/soft float, "));
15031           break;
15032         case 1:
15033           printf (_("hard float, "));
15034           break;
15035         case 2:
15036           printf (_("soft float, "));
15037           break;
15038         case 3:
15039           printf (_("single-precision hard float, "));
15040           break;
15041         }
15042
15043       switch (val & 0xC)
15044         {
15045         case 0:
15046           printf (_("unspecified long double\n"));
15047           break;
15048         case 4:
15049           printf (_("128-bit IBM long double\n"));
15050           break;
15051         case 8:
15052           printf (_("64-bit long double\n"));
15053           break;
15054         case 12:
15055           printf (_("128-bit IEEE long double\n"));
15056           break;
15057         }
15058       return p;
15059     }
15060
15061   if (tag == Tag_GNU_Power_ABI_Vector)
15062     {
15063       val = read_uleb128 (p, &len, end);
15064       p += len;
15065       printf ("  Tag_GNU_Power_ABI_Vector: ");
15066       if (len == 0)
15067         {
15068           printf (_("<corrupt>\n"));
15069           return p;
15070         }
15071
15072       if (val > 3)
15073         printf ("(%#x), ", val);
15074
15075       switch (val & 3)
15076         {
15077         case 0:
15078           printf (_("unspecified\n"));
15079           break;
15080         case 1:
15081           printf (_("generic\n"));
15082           break;
15083         case 2:
15084           printf ("AltiVec\n");
15085           break;
15086         case 3:
15087           printf ("SPE\n");
15088           break;
15089         }
15090       return p;
15091     }
15092
15093   if (tag == Tag_GNU_Power_ABI_Struct_Return)
15094     {
15095       val = read_uleb128 (p, &len, end);
15096       p += len;
15097       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
15098       if (len == 0)
15099         {
15100           printf (_("<corrupt>\n"));
15101           return p;
15102         }
15103
15104       if (val > 2)
15105         printf ("(%#x), ", val);
15106
15107       switch (val & 3)
15108         {
15109         case 0:
15110           printf (_("unspecified\n"));
15111           break;
15112         case 1:
15113           printf ("r3/r4\n");
15114           break;
15115         case 2:
15116           printf (_("memory\n"));
15117           break;
15118         case 3:
15119           printf ("???\n");
15120           break;
15121         }
15122       return p;
15123     }
15124
15125   return display_tag_value (tag & 1, p, end);
15126 }
15127
15128 static unsigned char *
15129 display_s390_gnu_attribute (unsigned char * p,
15130                             unsigned int tag,
15131                             const unsigned char * const end)
15132 {
15133   unsigned int len;
15134   int val;
15135
15136   if (tag == Tag_GNU_S390_ABI_Vector)
15137     {
15138       val = read_uleb128 (p, &len, end);
15139       p += len;
15140       printf ("  Tag_GNU_S390_ABI_Vector: ");
15141
15142       switch (val)
15143         {
15144         case 0:
15145           printf (_("any\n"));
15146           break;
15147         case 1:
15148           printf (_("software\n"));
15149           break;
15150         case 2:
15151           printf (_("hardware\n"));
15152           break;
15153         default:
15154           printf ("??? (%d)\n", val);
15155           break;
15156         }
15157       return p;
15158    }
15159
15160   return display_tag_value (tag & 1, p, end);
15161 }
15162
15163 static void
15164 display_sparc_hwcaps (unsigned int mask)
15165 {
15166   if (mask)
15167     {
15168       bfd_boolean first = TRUE;
15169
15170       if (mask & ELF_SPARC_HWCAP_MUL32)
15171         fputs ("mul32", stdout), first = FALSE;
15172       if (mask & ELF_SPARC_HWCAP_DIV32)
15173         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
15174       if (mask & ELF_SPARC_HWCAP_FSMULD)
15175         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
15176       if (mask & ELF_SPARC_HWCAP_V8PLUS)
15177         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
15178       if (mask & ELF_SPARC_HWCAP_POPC)
15179         printf ("%spopc", first ? "" : "|"), first = FALSE;
15180       if (mask & ELF_SPARC_HWCAP_VIS)
15181         printf ("%svis", first ? "" : "|"), first = FALSE;
15182       if (mask & ELF_SPARC_HWCAP_VIS2)
15183         printf ("%svis2", first ? "" : "|"), first = FALSE;
15184       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
15185         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
15186       if (mask & ELF_SPARC_HWCAP_FMAF)
15187         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
15188       if (mask & ELF_SPARC_HWCAP_VIS3)
15189         printf ("%svis3", first ? "" : "|"), first = FALSE;
15190       if (mask & ELF_SPARC_HWCAP_HPC)
15191         printf ("%shpc", first ? "" : "|"), first = FALSE;
15192       if (mask & ELF_SPARC_HWCAP_RANDOM)
15193         printf ("%srandom", first ? "" : "|"), first = FALSE;
15194       if (mask & ELF_SPARC_HWCAP_TRANS)
15195         printf ("%strans", first ? "" : "|"), first = FALSE;
15196       if (mask & ELF_SPARC_HWCAP_FJFMAU)
15197         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
15198       if (mask & ELF_SPARC_HWCAP_IMA)
15199         printf ("%sima", first ? "" : "|"), first = FALSE;
15200       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
15201         printf ("%scspare", first ? "" : "|"), first = FALSE;
15202     }
15203   else
15204     fputc ('0', stdout);
15205   fputc ('\n', stdout);
15206 }
15207
15208 static void
15209 display_sparc_hwcaps2 (unsigned int mask)
15210 {
15211   if (mask)
15212     {
15213       bfd_boolean first = TRUE;
15214
15215       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
15216         fputs ("fjathplus", stdout), first = FALSE;
15217       if (mask & ELF_SPARC_HWCAP2_VIS3B)
15218         printf ("%svis3b", first ? "" : "|"), first = FALSE;
15219       if (mask & ELF_SPARC_HWCAP2_ADP)
15220         printf ("%sadp", first ? "" : "|"), first = FALSE;
15221       if (mask & ELF_SPARC_HWCAP2_SPARC5)
15222         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
15223       if (mask & ELF_SPARC_HWCAP2_MWAIT)
15224         printf ("%smwait", first ? "" : "|"), first = FALSE;
15225       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
15226         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
15227       if (mask & ELF_SPARC_HWCAP2_XMONT)
15228         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
15229       if (mask & ELF_SPARC_HWCAP2_NSEC)
15230         printf ("%snsec", first ? "" : "|"), first = FALSE;
15231       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
15232         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
15233       if (mask & ELF_SPARC_HWCAP2_FJDES)
15234         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
15235       if (mask & ELF_SPARC_HWCAP2_FJAES)
15236         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
15237     }
15238   else
15239     fputc ('0', stdout);
15240   fputc ('\n', stdout);
15241 }
15242
15243 static unsigned char *
15244 display_sparc_gnu_attribute (unsigned char * p,
15245                              unsigned int tag,
15246                              const unsigned char * const end)
15247 {
15248   unsigned int len;
15249   int val;
15250
15251   if (tag == Tag_GNU_Sparc_HWCAPS)
15252     {
15253       val = read_uleb128 (p, &len, end);
15254       p += len;
15255       printf ("  Tag_GNU_Sparc_HWCAPS: ");
15256       display_sparc_hwcaps (val);
15257       return p;
15258     }
15259   if (tag == Tag_GNU_Sparc_HWCAPS2)
15260     {
15261       val = read_uleb128 (p, &len, end);
15262       p += len;
15263       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
15264       display_sparc_hwcaps2 (val);
15265       return p;
15266     }
15267
15268   return display_tag_value (tag, p, end);
15269 }
15270
15271 static void
15272 print_mips_fp_abi_value (unsigned int val)
15273 {
15274   switch (val)
15275     {
15276     case Val_GNU_MIPS_ABI_FP_ANY:
15277       printf (_("Hard or soft float\n"));
15278       break;
15279     case Val_GNU_MIPS_ABI_FP_DOUBLE:
15280       printf (_("Hard float (double precision)\n"));
15281       break;
15282     case Val_GNU_MIPS_ABI_FP_SINGLE:
15283       printf (_("Hard float (single precision)\n"));
15284       break;
15285     case Val_GNU_MIPS_ABI_FP_SOFT:
15286       printf (_("Soft float\n"));
15287       break;
15288     case Val_GNU_MIPS_ABI_FP_OLD_64:
15289       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15290       break;
15291     case Val_GNU_MIPS_ABI_FP_XX:
15292       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15293       break;
15294     case Val_GNU_MIPS_ABI_FP_64:
15295       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15296       break;
15297     case Val_GNU_MIPS_ABI_FP_64A:
15298       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15299       break;
15300     case Val_GNU_MIPS_ABI_FP_NAN2008:
15301       printf (_("NaN 2008 compatibility\n"));
15302       break;
15303     default:
15304       printf ("??? (%d)\n", val);
15305       break;
15306     }
15307 }
15308
15309 static unsigned char *
15310 display_mips_gnu_attribute (unsigned char * p,
15311                             unsigned int tag,
15312                             const unsigned char * const end)
15313 {
15314   if (tag == Tag_GNU_MIPS_ABI_FP)
15315     {
15316       unsigned int len;
15317       unsigned int val;
15318
15319       val = read_uleb128 (p, &len, end);
15320       p += len;
15321       printf ("  Tag_GNU_MIPS_ABI_FP: ");
15322
15323       print_mips_fp_abi_value (val);
15324
15325       return p;
15326    }
15327
15328   if (tag == Tag_GNU_MIPS_ABI_MSA)
15329     {
15330       unsigned int len;
15331       unsigned int val;
15332
15333       val = read_uleb128 (p, &len, end);
15334       p += len;
15335       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
15336
15337       switch (val)
15338         {
15339         case Val_GNU_MIPS_ABI_MSA_ANY:
15340           printf (_("Any MSA or not\n"));
15341           break;
15342         case Val_GNU_MIPS_ABI_MSA_128:
15343           printf (_("128-bit MSA\n"));
15344           break;
15345         default:
15346           printf ("??? (%d)\n", val);
15347           break;
15348         }
15349       return p;
15350     }
15351
15352   return display_tag_value (tag & 1, p, end);
15353 }
15354
15355 static unsigned char *
15356 display_tic6x_attribute (unsigned char * p,
15357                          const unsigned char * const end)
15358 {
15359   unsigned int tag;
15360   unsigned int len;
15361   int val;
15362
15363   tag = read_uleb128 (p, &len, end);
15364   p += len;
15365
15366   switch (tag)
15367     {
15368     case Tag_ISA:
15369       val = read_uleb128 (p, &len, end);
15370       p += len;
15371       printf ("  Tag_ISA: ");
15372
15373       switch (val)
15374         {
15375         case C6XABI_Tag_ISA_none:
15376           printf (_("None\n"));
15377           break;
15378         case C6XABI_Tag_ISA_C62X:
15379           printf ("C62x\n");
15380           break;
15381         case C6XABI_Tag_ISA_C67X:
15382           printf ("C67x\n");
15383           break;
15384         case C6XABI_Tag_ISA_C67XP:
15385           printf ("C67x+\n");
15386           break;
15387         case C6XABI_Tag_ISA_C64X:
15388           printf ("C64x\n");
15389           break;
15390         case C6XABI_Tag_ISA_C64XP:
15391           printf ("C64x+\n");
15392           break;
15393         case C6XABI_Tag_ISA_C674X:
15394           printf ("C674x\n");
15395           break;
15396         default:
15397           printf ("??? (%d)\n", val);
15398           break;
15399         }
15400       return p;
15401
15402     case Tag_ABI_wchar_t:
15403       val = read_uleb128 (p, &len, end);
15404       p += len;
15405       printf ("  Tag_ABI_wchar_t: ");
15406       switch (val)
15407         {
15408         case 0:
15409           printf (_("Not used\n"));
15410           break;
15411         case 1:
15412           printf (_("2 bytes\n"));
15413           break;
15414         case 2:
15415           printf (_("4 bytes\n"));
15416           break;
15417         default:
15418           printf ("??? (%d)\n", val);
15419           break;
15420         }
15421       return p;
15422
15423     case Tag_ABI_stack_align_needed:
15424       val = read_uleb128 (p, &len, end);
15425       p += len;
15426       printf ("  Tag_ABI_stack_align_needed: ");
15427       switch (val)
15428         {
15429         case 0:
15430           printf (_("8-byte\n"));
15431           break;
15432         case 1:
15433           printf (_("16-byte\n"));
15434           break;
15435         default:
15436           printf ("??? (%d)\n", val);
15437           break;
15438         }
15439       return p;
15440
15441     case Tag_ABI_stack_align_preserved:
15442       val = read_uleb128 (p, &len, end);
15443       p += len;
15444       printf ("  Tag_ABI_stack_align_preserved: ");
15445       switch (val)
15446         {
15447         case 0:
15448           printf (_("8-byte\n"));
15449           break;
15450         case 1:
15451           printf (_("16-byte\n"));
15452           break;
15453         default:
15454           printf ("??? (%d)\n", val);
15455           break;
15456         }
15457       return p;
15458
15459     case Tag_ABI_DSBT:
15460       val = read_uleb128 (p, &len, end);
15461       p += len;
15462       printf ("  Tag_ABI_DSBT: ");
15463       switch (val)
15464         {
15465         case 0:
15466           printf (_("DSBT addressing not used\n"));
15467           break;
15468         case 1:
15469           printf (_("DSBT addressing used\n"));
15470           break;
15471         default:
15472           printf ("??? (%d)\n", val);
15473           break;
15474         }
15475       return p;
15476
15477     case Tag_ABI_PID:
15478       val = read_uleb128 (p, &len, end);
15479       p += len;
15480       printf ("  Tag_ABI_PID: ");
15481       switch (val)
15482         {
15483         case 0:
15484           printf (_("Data addressing position-dependent\n"));
15485           break;
15486         case 1:
15487           printf (_("Data addressing position-independent, GOT near DP\n"));
15488           break;
15489         case 2:
15490           printf (_("Data addressing position-independent, GOT far from DP\n"));
15491           break;
15492         default:
15493           printf ("??? (%d)\n", val);
15494           break;
15495         }
15496       return p;
15497
15498     case Tag_ABI_PIC:
15499       val = read_uleb128 (p, &len, end);
15500       p += len;
15501       printf ("  Tag_ABI_PIC: ");
15502       switch (val)
15503         {
15504         case 0:
15505           printf (_("Code addressing position-dependent\n"));
15506           break;
15507         case 1:
15508           printf (_("Code addressing position-independent\n"));
15509           break;
15510         default:
15511           printf ("??? (%d)\n", val);
15512           break;
15513         }
15514       return p;
15515
15516     case Tag_ABI_array_object_alignment:
15517       val = read_uleb128 (p, &len, end);
15518       p += len;
15519       printf ("  Tag_ABI_array_object_alignment: ");
15520       switch (val)
15521         {
15522         case 0:
15523           printf (_("8-byte\n"));
15524           break;
15525         case 1:
15526           printf (_("4-byte\n"));
15527           break;
15528         case 2:
15529           printf (_("16-byte\n"));
15530           break;
15531         default:
15532           printf ("??? (%d)\n", val);
15533           break;
15534         }
15535       return p;
15536
15537     case Tag_ABI_array_object_align_expected:
15538       val = read_uleb128 (p, &len, end);
15539       p += len;
15540       printf ("  Tag_ABI_array_object_align_expected: ");
15541       switch (val)
15542         {
15543         case 0:
15544           printf (_("8-byte\n"));
15545           break;
15546         case 1:
15547           printf (_("4-byte\n"));
15548           break;
15549         case 2:
15550           printf (_("16-byte\n"));
15551           break;
15552         default:
15553           printf ("??? (%d)\n", val);
15554           break;
15555         }
15556       return p;
15557
15558     case Tag_ABI_compatibility:
15559       {
15560         val = read_uleb128 (p, &len, end);
15561         p += len;
15562         printf ("  Tag_ABI_compatibility: ");
15563         printf (_("flag = %d, vendor = "), val);
15564         if (p < end - 1)
15565           {
15566             size_t maxlen = (end - p) - 1;
15567
15568             print_symbol ((int) maxlen, (const char *) p);
15569             p += strnlen ((char *) p, maxlen) + 1;
15570           }
15571         else
15572           {
15573             printf (_("<corrupt>"));
15574             p = (unsigned char *) end;
15575           }
15576         putchar ('\n');
15577         return p;
15578       }
15579
15580     case Tag_ABI_conformance:
15581       {
15582         printf ("  Tag_ABI_conformance: \"");
15583         if (p < end - 1)
15584           {
15585             size_t maxlen = (end - p) - 1;
15586
15587             print_symbol ((int) maxlen, (const char *) p);
15588             p += strnlen ((char *) p, maxlen) + 1;
15589           }
15590         else
15591           {
15592             printf (_("<corrupt>"));
15593             p = (unsigned char *) end;
15594           }
15595         printf ("\"\n");
15596         return p;
15597       }
15598     }
15599
15600   return display_tag_value (tag, p, end);
15601 }
15602
15603 static void
15604 display_raw_attribute (unsigned char * p, unsigned char const * const end)
15605 {
15606   unsigned long addr = 0;
15607   size_t bytes = end - p;
15608
15609   assert (end >= p);
15610   while (bytes)
15611     {
15612       int j;
15613       int k;
15614       int lbytes = (bytes > 16 ? 16 : bytes);
15615
15616       printf ("  0x%8.8lx ", addr);
15617
15618       for (j = 0; j < 16; j++)
15619         {
15620           if (j < lbytes)
15621             printf ("%2.2x", p[j]);
15622           else
15623             printf ("  ");
15624
15625           if ((j & 3) == 3)
15626             printf (" ");
15627         }
15628
15629       for (j = 0; j < lbytes; j++)
15630         {
15631           k = p[j];
15632           if (k >= ' ' && k < 0x7f)
15633             printf ("%c", k);
15634           else
15635             printf (".");
15636         }
15637
15638       putchar ('\n');
15639
15640       p  += lbytes;
15641       bytes -= lbytes;
15642       addr += lbytes;
15643     }
15644
15645   putchar ('\n');
15646 }
15647
15648 static unsigned char *
15649 display_msp430x_attribute (unsigned char * p,
15650                            const unsigned char * const end)
15651 {
15652   unsigned int len;
15653   unsigned int val;
15654   unsigned int tag;
15655
15656   tag = read_uleb128 (p, & len, end);
15657   p += len;
15658
15659   switch (tag)
15660     {
15661     case OFBA_MSPABI_Tag_ISA:
15662       val = read_uleb128 (p, &len, end);
15663       p += len;
15664       printf ("  Tag_ISA: ");
15665       switch (val)
15666         {
15667         case 0: printf (_("None\n")); break;
15668         case 1: printf (_("MSP430\n")); break;
15669         case 2: printf (_("MSP430X\n")); break;
15670         default: printf ("??? (%d)\n", val); break;
15671         }
15672       break;
15673
15674     case OFBA_MSPABI_Tag_Code_Model:
15675       val = read_uleb128 (p, &len, end);
15676       p += len;
15677       printf ("  Tag_Code_Model: ");
15678       switch (val)
15679         {
15680         case 0: printf (_("None\n")); break;
15681         case 1: printf (_("Small\n")); break;
15682         case 2: printf (_("Large\n")); break;
15683         default: printf ("??? (%d)\n", val); break;
15684         }
15685       break;
15686
15687     case OFBA_MSPABI_Tag_Data_Model:
15688       val = read_uleb128 (p, &len, end);
15689       p += len;
15690       printf ("  Tag_Data_Model: ");
15691       switch (val)
15692         {
15693         case 0: printf (_("None\n")); break;
15694         case 1: printf (_("Small\n")); break;
15695         case 2: printf (_("Large\n")); break;
15696         case 3: printf (_("Restricted Large\n")); break;
15697         default: printf ("??? (%d)\n", val); break;
15698         }
15699       break;
15700
15701     default:
15702       printf (_("  <unknown tag %d>: "), tag);
15703
15704       if (tag & 1)
15705         {
15706           putchar ('"');
15707           if (p < end - 1)
15708             {
15709               size_t maxlen = (end - p) - 1;
15710
15711               print_symbol ((int) maxlen, (const char *) p);
15712               p += strnlen ((char *) p, maxlen) + 1;
15713             }
15714           else
15715             {
15716               printf (_("<corrupt>"));
15717               p = (unsigned char *) end;
15718             }
15719           printf ("\"\n");
15720         }
15721       else
15722         {
15723           val = read_uleb128 (p, &len, end);
15724           p += len;
15725           printf ("%d (0x%x)\n", val, val);
15726         }
15727       break;
15728    }
15729
15730   assert (p <= end);
15731   return p;
15732 }
15733
15734 struct riscv_attr_tag_t {
15735   const char *name;
15736   int tag;
15737 };
15738
15739 static struct riscv_attr_tag_t riscv_attr_tag[] =
15740 {
15741 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
15742   T(arch),
15743   T(priv_spec),
15744   T(priv_spec_minor),
15745   T(priv_spec_revision),
15746   T(unaligned_access),
15747   T(stack_align),
15748 #undef T
15749 };
15750
15751 static unsigned char *
15752 display_riscv_attribute (unsigned char *p,
15753                          const unsigned char * const end)
15754 {
15755   unsigned int len;
15756   int val;
15757   int tag;
15758   struct riscv_attr_tag_t *attr = NULL;
15759   unsigned i;
15760
15761   tag = read_uleb128 (p, &len, end);
15762   p += len;
15763
15764   /* Find the name of attribute. */
15765   for (i = 0; i < ARRAY_SIZE (riscv_attr_tag); i++)
15766     {
15767       if (riscv_attr_tag[i].tag == tag)
15768         {
15769           attr = &riscv_attr_tag[i];
15770           break;
15771         }
15772     }
15773
15774   if (attr)
15775     printf ("  %s: ", attr->name);
15776   else
15777     return display_tag_value (tag, p, end);
15778
15779   switch (tag)
15780     {
15781     case Tag_RISCV_priv_spec:
15782     case Tag_RISCV_priv_spec_minor:
15783     case Tag_RISCV_priv_spec_revision:
15784       val = read_uleb128 (p, &len, end);
15785       p += len;
15786       printf (_("%d\n"), val);
15787       break;
15788     case Tag_RISCV_unaligned_access:
15789       val = read_uleb128 (p, &len, end);
15790       p += len;
15791       switch (val)
15792         {
15793         case 0:
15794           printf (_("No unaligned access\n"));
15795           break;
15796         case 1:
15797           printf (_("Unaligned access\n"));
15798           break;
15799         }
15800       break;
15801     case Tag_RISCV_stack_align:
15802       val = read_uleb128 (p, &len, end);
15803       p += len;
15804       printf (_("%d-bytes\n"), val);
15805       break;
15806     case Tag_RISCV_arch:
15807       p = display_tag_value (-1, p, end);
15808       break;
15809     default:
15810       return display_tag_value (tag, p, end);
15811     }
15812
15813   return p;
15814 }
15815
15816 static bfd_boolean
15817 process_attributes (Filedata * filedata,
15818                     const char * public_name,
15819                     unsigned int proc_type,
15820                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15821                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15822 {
15823   Elf_Internal_Shdr * sect;
15824   unsigned i;
15825   bfd_boolean res = TRUE;
15826
15827   /* Find the section header so that we get the size.  */
15828   for (i = 0, sect = filedata->section_headers;
15829        i < filedata->file_header.e_shnum;
15830        i++, sect++)
15831     {
15832       unsigned char * contents;
15833       unsigned char * p;
15834
15835       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15836         continue;
15837
15838       contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15839                                              sect->sh_size, _("attributes"));
15840       if (contents == NULL)
15841         {
15842           res = FALSE;
15843           continue;
15844         }
15845
15846       p = contents;
15847       /* The first character is the version of the attributes.
15848          Currently only version 1, (aka 'A') is recognised here.  */
15849       if (*p != 'A')
15850         {
15851           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15852           res = FALSE;
15853         }
15854       else
15855         {
15856           bfd_vma section_len;
15857
15858           section_len = sect->sh_size - 1;
15859           p++;
15860
15861           while (section_len > 0)
15862             {
15863               bfd_vma attr_len;
15864               unsigned int namelen;
15865               bfd_boolean public_section;
15866               bfd_boolean gnu_section;
15867
15868               if (section_len <= 4)
15869                 {
15870                   error (_("Tag section ends prematurely\n"));
15871                   res = FALSE;
15872                   break;
15873                 }
15874               attr_len = byte_get (p, 4);
15875               p += 4;
15876
15877               if (attr_len > section_len)
15878                 {
15879                   error (_("Bad attribute length (%u > %u)\n"),
15880                           (unsigned) attr_len, (unsigned) section_len);
15881                   attr_len = section_len;
15882                   res = FALSE;
15883                 }
15884               /* PR 17531: file: 001-101425-0.004  */
15885               else if (attr_len < 5)
15886                 {
15887                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
15888                   res = FALSE;
15889                   break;
15890                 }
15891
15892               section_len -= attr_len;
15893               attr_len -= 4;
15894
15895               namelen = strnlen ((char *) p, attr_len) + 1;
15896               if (namelen == 0 || namelen >= attr_len)
15897                 {
15898                   error (_("Corrupt attribute section name\n"));
15899                   res = FALSE;
15900                   break;
15901                 }
15902
15903               printf (_("Attribute Section: "));
15904               print_symbol (INT_MAX, (const char *) p);
15905               putchar ('\n');
15906
15907               if (public_name && streq ((char *) p, public_name))
15908                 public_section = TRUE;
15909               else
15910                 public_section = FALSE;
15911
15912               if (streq ((char *) p, "gnu"))
15913                 gnu_section = TRUE;
15914               else
15915                 gnu_section = FALSE;
15916
15917               p += namelen;
15918               attr_len -= namelen;
15919
15920               while (attr_len > 0 && p < contents + sect->sh_size)
15921                 {
15922                   int tag;
15923                   int val;
15924                   bfd_vma size;
15925                   unsigned char * end;
15926
15927                   /* PR binutils/17531: Safe handling of corrupt files.  */
15928                   if (attr_len < 6)
15929                     {
15930                       error (_("Unused bytes at end of section\n"));
15931                       res = FALSE;
15932                       section_len = 0;
15933                       break;
15934                     }
15935
15936                   tag = *(p++);
15937                   size = byte_get (p, 4);
15938                   if (size > attr_len)
15939                     {
15940                       error (_("Bad subsection length (%u > %u)\n"),
15941                               (unsigned) size, (unsigned) attr_len);
15942                       res = FALSE;
15943                       size = attr_len;
15944                     }
15945                   /* PR binutils/17531: Safe handling of corrupt files.  */
15946                   if (size < 6)
15947                     {
15948                       error (_("Bad subsection length (%u < 6)\n"),
15949                               (unsigned) size);
15950                       res = FALSE;
15951                       section_len = 0;
15952                       break;
15953                     }
15954
15955                   attr_len -= size;
15956                   end = p + size - 1;
15957                   assert (end <= contents + sect->sh_size);
15958                   p += 4;
15959
15960                   switch (tag)
15961                     {
15962                     case 1:
15963                       printf (_("File Attributes\n"));
15964                       break;
15965                     case 2:
15966                       printf (_("Section Attributes:"));
15967                       goto do_numlist;
15968                     case 3:
15969                       printf (_("Symbol Attributes:"));
15970                       /* Fall through.  */
15971                     do_numlist:
15972                       for (;;)
15973                         {
15974                           unsigned int j;
15975
15976                           val = read_uleb128 (p, &j, end);
15977                           p += j;
15978                           if (val == 0)
15979                             break;
15980                           printf (" %d", val);
15981                         }
15982                       printf ("\n");
15983                       break;
15984                     default:
15985                       printf (_("Unknown tag: %d\n"), tag);
15986                       public_section = FALSE;
15987                       break;
15988                     }
15989
15990                   if (public_section && display_pub_attribute != NULL)
15991                     {
15992                       while (p < end)
15993                         p = display_pub_attribute (p, end);
15994                       assert (p == end);
15995                     }
15996                   else if (gnu_section && display_proc_gnu_attribute != NULL)
15997                     {
15998                       while (p < end)
15999                         p = display_gnu_attribute (p,
16000                                                    display_proc_gnu_attribute,
16001                                                    end);
16002                       assert (p == end);
16003                     }
16004                   else if (p < end)
16005                     {
16006                       printf (_("  Unknown attribute:\n"));
16007                       display_raw_attribute (p, end);
16008                       p = end;
16009                     }
16010                   else
16011                     attr_len = 0;
16012                 }
16013             }
16014         }
16015
16016       free (contents);
16017     }
16018
16019   return res;
16020 }
16021
16022 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16023    Print the Address, Access and Initial fields of an entry at VMA ADDR
16024    and return the VMA of the next entry, or -1 if there was a problem.
16025    Does not read from DATA_END or beyond.  */
16026
16027 static bfd_vma
16028 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
16029                       unsigned char * data_end)
16030 {
16031   printf ("  ");
16032   print_vma (addr, LONG_HEX);
16033   printf (" ");
16034   if (addr < pltgot + 0xfff0)
16035     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
16036   else
16037     printf ("%10s", "");
16038   printf (" ");
16039   if (data == NULL)
16040     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
16041   else
16042     {
16043       bfd_vma entry;
16044       unsigned char * from = data + addr - pltgot;
16045
16046       if (from + (is_32bit_elf ? 4 : 8) > data_end)
16047         {
16048           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16049           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
16050           return (bfd_vma) -1;
16051         }
16052       else
16053         {
16054           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
16055           print_vma (entry, LONG_HEX);
16056         }
16057     }
16058   return addr + (is_32bit_elf ? 4 : 8);
16059 }
16060
16061 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16062    PLTGOT.  Print the Address and Initial fields of an entry at VMA
16063    ADDR and return the VMA of the next entry.  */
16064
16065 static bfd_vma
16066 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
16067 {
16068   printf ("  ");
16069   print_vma (addr, LONG_HEX);
16070   printf (" ");
16071   if (data == NULL)
16072     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
16073   else
16074     {
16075       bfd_vma entry;
16076
16077       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
16078       print_vma (entry, LONG_HEX);
16079     }
16080   return addr + (is_32bit_elf ? 4 : 8);
16081 }
16082
16083 static void
16084 print_mips_ases (unsigned int mask)
16085 {
16086   if (mask & AFL_ASE_DSP)
16087     fputs ("\n\tDSP ASE", stdout);
16088   if (mask & AFL_ASE_DSPR2)
16089     fputs ("\n\tDSP R2 ASE", stdout);
16090   if (mask & AFL_ASE_DSPR3)
16091     fputs ("\n\tDSP R3 ASE", stdout);
16092   if (mask & AFL_ASE_EVA)
16093     fputs ("\n\tEnhanced VA Scheme", stdout);
16094   if (mask & AFL_ASE_MCU)
16095     fputs ("\n\tMCU (MicroController) ASE", stdout);
16096   if (mask & AFL_ASE_MDMX)
16097     fputs ("\n\tMDMX ASE", stdout);
16098   if (mask & AFL_ASE_MIPS3D)
16099     fputs ("\n\tMIPS-3D ASE", stdout);
16100   if (mask & AFL_ASE_MT)
16101     fputs ("\n\tMT ASE", stdout);
16102   if (mask & AFL_ASE_SMARTMIPS)
16103     fputs ("\n\tSmartMIPS ASE", stdout);
16104   if (mask & AFL_ASE_VIRT)
16105     fputs ("\n\tVZ ASE", stdout);
16106   if (mask & AFL_ASE_MSA)
16107     fputs ("\n\tMSA ASE", stdout);
16108   if (mask & AFL_ASE_MIPS16)
16109     fputs ("\n\tMIPS16 ASE", stdout);
16110   if (mask & AFL_ASE_MICROMIPS)
16111     fputs ("\n\tMICROMIPS ASE", stdout);
16112   if (mask & AFL_ASE_XPA)
16113     fputs ("\n\tXPA ASE", stdout);
16114   if (mask & AFL_ASE_MIPS16E2)
16115     fputs ("\n\tMIPS16e2 ASE", stdout);
16116   if (mask & AFL_ASE_CRC)
16117     fputs ("\n\tCRC ASE", stdout);
16118   if (mask & AFL_ASE_GINV)
16119     fputs ("\n\tGINV ASE", stdout);
16120   if (mask & AFL_ASE_LOONGSON_MMI)
16121     fputs ("\n\tLoongson MMI ASE", stdout);
16122   if (mask & AFL_ASE_LOONGSON_CAM)
16123     fputs ("\n\tLoongson CAM ASE", stdout);
16124   if (mask & AFL_ASE_LOONGSON_EXT)
16125     fputs ("\n\tLoongson EXT ASE", stdout);
16126   if (mask & AFL_ASE_LOONGSON_EXT2)
16127     fputs ("\n\tLoongson EXT2 ASE", stdout);
16128   if (mask == 0)
16129     fprintf (stdout, "\n\t%s", _("None"));
16130   else if ((mask & ~AFL_ASE_MASK) != 0)
16131     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
16132 }
16133
16134 static void
16135 print_mips_isa_ext (unsigned int isa_ext)
16136 {
16137   switch (isa_ext)
16138     {
16139     case 0:
16140       fputs (_("None"), stdout);
16141       break;
16142     case AFL_EXT_XLR:
16143       fputs ("RMI XLR", stdout);
16144       break;
16145     case AFL_EXT_OCTEON3:
16146       fputs ("Cavium Networks Octeon3", stdout);
16147       break;
16148     case AFL_EXT_OCTEON2:
16149       fputs ("Cavium Networks Octeon2", stdout);
16150       break;
16151     case AFL_EXT_OCTEONP:
16152       fputs ("Cavium Networks OcteonP", stdout);
16153       break;
16154     case AFL_EXT_OCTEON:
16155       fputs ("Cavium Networks Octeon", stdout);
16156       break;
16157     case AFL_EXT_5900:
16158       fputs ("Toshiba R5900", stdout);
16159       break;
16160     case AFL_EXT_4650:
16161       fputs ("MIPS R4650", stdout);
16162       break;
16163     case AFL_EXT_4010:
16164       fputs ("LSI R4010", stdout);
16165       break;
16166     case AFL_EXT_4100:
16167       fputs ("NEC VR4100", stdout);
16168       break;
16169     case AFL_EXT_3900:
16170       fputs ("Toshiba R3900", stdout);
16171       break;
16172     case AFL_EXT_10000:
16173       fputs ("MIPS R10000", stdout);
16174       break;
16175     case AFL_EXT_SB1:
16176       fputs ("Broadcom SB-1", stdout);
16177       break;
16178     case AFL_EXT_4111:
16179       fputs ("NEC VR4111/VR4181", stdout);
16180       break;
16181     case AFL_EXT_4120:
16182       fputs ("NEC VR4120", stdout);
16183       break;
16184     case AFL_EXT_5400:
16185       fputs ("NEC VR5400", stdout);
16186       break;
16187     case AFL_EXT_5500:
16188       fputs ("NEC VR5500", stdout);
16189       break;
16190     case AFL_EXT_LOONGSON_2E:
16191       fputs ("ST Microelectronics Loongson 2E", stdout);
16192       break;
16193     case AFL_EXT_LOONGSON_2F:
16194       fputs ("ST Microelectronics Loongson 2F", stdout);
16195       break;
16196     case AFL_EXT_INTERAPTIV_MR2:
16197       fputs ("Imagination interAptiv MR2", stdout);
16198       break;
16199     default:
16200       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
16201     }
16202 }
16203
16204 static signed int
16205 get_mips_reg_size (int reg_size)
16206 {
16207   return (reg_size == AFL_REG_NONE) ? 0
16208          : (reg_size == AFL_REG_32) ? 32
16209          : (reg_size == AFL_REG_64) ? 64
16210          : (reg_size == AFL_REG_128) ? 128
16211          : -1;
16212 }
16213
16214 static bfd_boolean
16215 process_mips_specific (Filedata * filedata)
16216 {
16217   Elf_Internal_Dyn * entry;
16218   Elf_Internal_Shdr *sect = NULL;
16219   size_t liblist_offset = 0;
16220   size_t liblistno = 0;
16221   size_t conflictsno = 0;
16222   size_t options_offset = 0;
16223   size_t conflicts_offset = 0;
16224   size_t pltrelsz = 0;
16225   size_t pltrel = 0;
16226   bfd_vma pltgot = 0;
16227   bfd_vma mips_pltgot = 0;
16228   bfd_vma jmprel = 0;
16229   bfd_vma local_gotno = 0;
16230   bfd_vma gotsym = 0;
16231   bfd_vma symtabno = 0;
16232   bfd_boolean res = TRUE;
16233
16234   if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
16235                             display_mips_gnu_attribute))
16236     res = FALSE;
16237
16238   sect = find_section (filedata, ".MIPS.abiflags");
16239
16240   if (sect != NULL)
16241     {
16242       Elf_External_ABIFlags_v0 *abiflags_ext;
16243       Elf_Internal_ABIFlags_v0 abiflags_in;
16244
16245       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
16246         {
16247           error (_("Corrupt MIPS ABI Flags section.\n"));
16248           res = FALSE;
16249         }
16250       else
16251         {
16252           abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
16253                                    sect->sh_size, _("MIPS ABI Flags section"));
16254           if (abiflags_ext)
16255             {
16256               abiflags_in.version = BYTE_GET (abiflags_ext->version);
16257               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
16258               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
16259               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
16260               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
16261               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
16262               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
16263               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
16264               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
16265               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
16266               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
16267
16268               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
16269               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
16270               if (abiflags_in.isa_rev > 1)
16271                 printf ("r%d", abiflags_in.isa_rev);
16272               printf ("\nGPR size: %d",
16273                       get_mips_reg_size (abiflags_in.gpr_size));
16274               printf ("\nCPR1 size: %d",
16275                       get_mips_reg_size (abiflags_in.cpr1_size));
16276               printf ("\nCPR2 size: %d",
16277                       get_mips_reg_size (abiflags_in.cpr2_size));
16278               fputs ("\nFP ABI: ", stdout);
16279               print_mips_fp_abi_value (abiflags_in.fp_abi);
16280               fputs ("ISA Extension: ", stdout);
16281               print_mips_isa_ext (abiflags_in.isa_ext);
16282               fputs ("\nASEs:", stdout);
16283               print_mips_ases (abiflags_in.ases);
16284               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
16285               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
16286               fputc ('\n', stdout);
16287               free (abiflags_ext);
16288             }
16289         }
16290     }
16291
16292   /* We have a lot of special sections.  Thanks SGI!  */
16293   if (dynamic_section == NULL)
16294     {
16295       /* No dynamic information available.  See if there is static GOT.  */
16296       sect = find_section (filedata, ".got");
16297       if (sect != NULL)
16298         {
16299           unsigned char *data_end;
16300           unsigned char *data;
16301           bfd_vma ent, end;
16302           int addr_size;
16303
16304           pltgot = sect->sh_addr;
16305
16306           ent = pltgot;
16307           addr_size = (is_32bit_elf ? 4 : 8);
16308           end = pltgot + sect->sh_size;
16309
16310           data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
16311                                              end - pltgot, 1,
16312                                              _("Global Offset Table data"));
16313           /* PR 12855: Null data is handled gracefully throughout.  */
16314           data_end = data + (end - pltgot);
16315
16316           printf (_("\nStatic GOT:\n"));
16317           printf (_(" Canonical gp value: "));
16318           print_vma (ent + 0x7ff0, LONG_HEX);
16319           printf ("\n\n");
16320
16321           /* In a dynamic binary GOT[0] is reserved for the dynamic
16322              loader to store the lazy resolver pointer, however in
16323              a static binary it may well have been omitted and GOT
16324              reduced to a table of addresses.
16325              PR 21344: Check for the entry being fully available
16326              before fetching it.  */
16327           if (data
16328               && data + ent - pltgot + addr_size <= data_end
16329               && byte_get (data + ent - pltgot, addr_size) == 0)
16330             {
16331               printf (_(" Reserved entries:\n"));
16332               printf (_("  %*s %10s %*s\n"),
16333                       addr_size * 2, _("Address"), _("Access"),
16334                       addr_size * 2, _("Value"));
16335               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16336               printf ("\n");
16337               if (ent == (bfd_vma) -1)
16338                 goto sgot_print_fail;
16339
16340               /* Check for the MSB of GOT[1] being set, identifying a
16341                  GNU object.  This entry will be used by some runtime
16342                  loaders, to store the module pointer.  Otherwise this
16343                  is an ordinary local entry.
16344                  PR 21344: Check for the entry being fully available
16345                  before fetching it.  */
16346               if (data
16347                   && data + ent - pltgot + addr_size <= data_end
16348                   && (byte_get (data + ent - pltgot, addr_size)
16349                       >> (addr_size * 8 - 1)) != 0)
16350                 {
16351                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
16352                   printf ("\n");
16353                   if (ent == (bfd_vma) -1)
16354                     goto sgot_print_fail;
16355                 }
16356               printf ("\n");
16357             }
16358
16359           if (data != NULL && ent < end)
16360             {
16361               printf (_(" Local entries:\n"));
16362               printf ("  %*s %10s %*s\n",
16363                       addr_size * 2, _("Address"), _("Access"),
16364                       addr_size * 2, _("Value"));
16365               while (ent < end)
16366                 {
16367                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
16368                   printf ("\n");
16369                   if (ent == (bfd_vma) -1)
16370                     goto sgot_print_fail;
16371                 }
16372               printf ("\n");
16373             }
16374
16375         sgot_print_fail:
16376           if (data)
16377             free (data);
16378         }
16379       return res;
16380     }
16381
16382   for (entry = dynamic_section;
16383        /* PR 17531 file: 012-50589-0.004.  */
16384        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
16385        ++entry)
16386     switch (entry->d_tag)
16387       {
16388       case DT_MIPS_LIBLIST:
16389         liblist_offset
16390           = offset_from_vma (filedata, entry->d_un.d_val,
16391                              liblistno * sizeof (Elf32_External_Lib));
16392         break;
16393       case DT_MIPS_LIBLISTNO:
16394         liblistno = entry->d_un.d_val;
16395         break;
16396       case DT_MIPS_OPTIONS:
16397         options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
16398         break;
16399       case DT_MIPS_CONFLICT:
16400         conflicts_offset
16401           = offset_from_vma (filedata, entry->d_un.d_val,
16402                              conflictsno * sizeof (Elf32_External_Conflict));
16403         break;
16404       case DT_MIPS_CONFLICTNO:
16405         conflictsno = entry->d_un.d_val;
16406         break;
16407       case DT_PLTGOT:
16408         pltgot = entry->d_un.d_ptr;
16409         break;
16410       case DT_MIPS_LOCAL_GOTNO:
16411         local_gotno = entry->d_un.d_val;
16412         break;
16413       case DT_MIPS_GOTSYM:
16414         gotsym = entry->d_un.d_val;
16415         break;
16416       case DT_MIPS_SYMTABNO:
16417         symtabno = entry->d_un.d_val;
16418         break;
16419       case DT_MIPS_PLTGOT:
16420         mips_pltgot = entry->d_un.d_ptr;
16421         break;
16422       case DT_PLTREL:
16423         pltrel = entry->d_un.d_val;
16424         break;
16425       case DT_PLTRELSZ:
16426         pltrelsz = entry->d_un.d_val;
16427         break;
16428       case DT_JMPREL:
16429         jmprel = entry->d_un.d_ptr;
16430         break;
16431       default:
16432         break;
16433       }
16434
16435   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
16436     {
16437       Elf32_External_Lib * elib;
16438       size_t cnt;
16439
16440       elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
16441                                               liblistno,
16442                                               sizeof (Elf32_External_Lib),
16443                                               _("liblist section data"));
16444       if (elib)
16445         {
16446           printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16447                             "\nSection '.liblist' contains %lu entries:\n",
16448                             (unsigned long) liblistno),
16449                   (unsigned long) liblistno);
16450           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
16451                  stdout);
16452
16453           for (cnt = 0; cnt < liblistno; ++cnt)
16454             {
16455               Elf32_Lib liblist;
16456               time_t atime;
16457               char timebuf[128];
16458               struct tm * tmp;
16459
16460               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16461               atime = BYTE_GET (elib[cnt].l_time_stamp);
16462               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16463               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16464               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16465
16466               tmp = gmtime (&atime);
16467               snprintf (timebuf, sizeof (timebuf),
16468                         "%04u-%02u-%02uT%02u:%02u:%02u",
16469                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16470                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16471
16472               printf ("%3lu: ", (unsigned long) cnt);
16473               if (VALID_DYNAMIC_NAME (liblist.l_name))
16474                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
16475               else
16476                 printf (_("<corrupt: %9ld>"), liblist.l_name);
16477               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
16478                       liblist.l_version);
16479
16480               if (liblist.l_flags == 0)
16481                 puts (_(" NONE"));
16482               else
16483                 {
16484                   static const struct
16485                   {
16486                     const char * name;
16487                     int bit;
16488                   }
16489                   l_flags_vals[] =
16490                   {
16491                     { " EXACT_MATCH", LL_EXACT_MATCH },
16492                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
16493                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
16494                     { " EXPORTS", LL_EXPORTS },
16495                     { " DELAY_LOAD", LL_DELAY_LOAD },
16496                     { " DELTA", LL_DELTA }
16497                   };
16498                   int flags = liblist.l_flags;
16499                   size_t fcnt;
16500
16501                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
16502                     if ((flags & l_flags_vals[fcnt].bit) != 0)
16503                       {
16504                         fputs (l_flags_vals[fcnt].name, stdout);
16505                         flags ^= l_flags_vals[fcnt].bit;
16506                       }
16507                   if (flags != 0)
16508                     printf (" %#x", (unsigned int) flags);
16509
16510                   puts ("");
16511                 }
16512             }
16513
16514           free (elib);
16515         }
16516       else
16517         res = FALSE;
16518     }
16519
16520   if (options_offset != 0)
16521     {
16522       Elf_External_Options * eopt;
16523       size_t offset;
16524       int cnt;
16525       sect = filedata->section_headers;
16526
16527       /* Find the section header so that we get the size.  */
16528       sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
16529       /* PR 17533 file: 012-277276-0.004.  */
16530       if (sect == NULL)
16531         {
16532           error (_("No MIPS_OPTIONS header found\n"));
16533           return FALSE;
16534         }
16535       /* PR 24243  */
16536       if (sect->sh_size < sizeof (* eopt))
16537         {
16538           error (_("The MIPS options section is too small.\n"));
16539           return FALSE;
16540         }
16541
16542       eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
16543                                                 sect->sh_size, _("options"));
16544       if (eopt)
16545         {
16546           Elf_Internal_Options * iopt;
16547           Elf_Internal_Options * option;
16548           Elf_Internal_Options * iopt_end;
16549
16550           iopt = (Elf_Internal_Options *)
16551               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
16552           if (iopt == NULL)
16553             {
16554               error (_("Out of memory allocating space for MIPS options\n"));
16555               return FALSE;
16556             }
16557
16558           offset = cnt = 0;
16559           option = iopt;
16560           iopt_end = iopt + (sect->sh_size / sizeof (eopt));
16561
16562           while (offset <= sect->sh_size - sizeof (* eopt))
16563             {
16564               Elf_External_Options * eoption;
16565
16566               eoption = (Elf_External_Options *) ((char *) eopt + offset);
16567
16568               option->kind = BYTE_GET (eoption->kind);
16569               option->size = BYTE_GET (eoption->size);
16570               option->section = BYTE_GET (eoption->section);
16571               option->info = BYTE_GET (eoption->info);
16572
16573               /* PR 17531: file: ffa0fa3b.  */
16574               if (option->size < sizeof (* eopt)
16575                   || offset + option->size > sect->sh_size)
16576                 {
16577                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
16578                   return FALSE;
16579                 }
16580               offset += option->size;
16581
16582               ++option;
16583               ++cnt;
16584             }
16585
16586           printf (ngettext ("\nSection '%s' contains %d entry:\n",
16587                             "\nSection '%s' contains %d entries:\n",
16588                             cnt),
16589                   printable_section_name (filedata, sect), cnt);
16590
16591           option = iopt;
16592           offset = 0;
16593
16594           while (cnt-- > 0)
16595             {
16596               size_t len;
16597
16598               switch (option->kind)
16599                 {
16600                 case ODK_NULL:
16601                   /* This shouldn't happen.  */
16602                   printf (" NULL       %d %lx", option->section, option->info);
16603                   break;
16604
16605                 case ODK_REGINFO:
16606                   printf (" REGINFO    ");
16607                   if (filedata->file_header.e_machine == EM_MIPS)
16608                     {
16609                       Elf32_External_RegInfo * ereg;
16610                       Elf32_RegInfo reginfo;
16611
16612                       /* 32bit form.  */
16613                       if (option + 2 > iopt_end)
16614                         {
16615                           printf (_("<corrupt>\n"));
16616                           error (_("Truncated MIPS REGINFO option\n"));
16617                           cnt = 0;
16618                           break;
16619                         }
16620
16621                       ereg = (Elf32_External_RegInfo *) (option + 1);
16622
16623                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16624                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16625                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16626                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16627                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16628                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16629
16630                       printf ("GPR %08lx  GP 0x%lx\n",
16631                               reginfo.ri_gprmask,
16632                               (unsigned long) reginfo.ri_gp_value);
16633                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
16634                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16635                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16636                     }
16637                   else
16638                     {
16639                       /* 64 bit form.  */
16640                       Elf64_External_RegInfo * ereg;
16641                       Elf64_Internal_RegInfo reginfo;
16642
16643                       if (option + 2 > iopt_end)
16644                         {
16645                           printf (_("<corrupt>\n"));
16646                           error (_("Truncated MIPS REGINFO option\n"));
16647                           cnt = 0;
16648                           break;
16649                         }
16650
16651                       ereg = (Elf64_External_RegInfo *) (option + 1);
16652                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
16653                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16654                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16655                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16656                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16657                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
16658
16659                       printf ("GPR %08lx  GP 0x",
16660                               reginfo.ri_gprmask);
16661                       printf_vma (reginfo.ri_gp_value);
16662                       printf ("\n");
16663
16664                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
16665                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16666                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16667                     }
16668                   ++option;
16669                   continue;
16670
16671                 case ODK_EXCEPTIONS:
16672                   fputs (" EXCEPTIONS fpe_min(", stdout);
16673                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
16674                   fputs (") fpe_max(", stdout);
16675                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
16676                   fputs (")", stdout);
16677
16678                   if (option->info & OEX_PAGE0)
16679                     fputs (" PAGE0", stdout);
16680                   if (option->info & OEX_SMM)
16681                     fputs (" SMM", stdout);
16682                   if (option->info & OEX_FPDBUG)
16683                     fputs (" FPDBUG", stdout);
16684                   if (option->info & OEX_DISMISS)
16685                     fputs (" DISMISS", stdout);
16686                   break;
16687
16688                 case ODK_PAD:
16689                   fputs (" PAD       ", stdout);
16690                   if (option->info & OPAD_PREFIX)
16691                     fputs (" PREFIX", stdout);
16692                   if (option->info & OPAD_POSTFIX)
16693                     fputs (" POSTFIX", stdout);
16694                   if (option->info & OPAD_SYMBOL)
16695                     fputs (" SYMBOL", stdout);
16696                   break;
16697
16698                 case ODK_HWPATCH:
16699                   fputs (" HWPATCH   ", stdout);
16700                   if (option->info & OHW_R4KEOP)
16701                     fputs (" R4KEOP", stdout);
16702                   if (option->info & OHW_R8KPFETCH)
16703                     fputs (" R8KPFETCH", stdout);
16704                   if (option->info & OHW_R5KEOP)
16705                     fputs (" R5KEOP", stdout);
16706                   if (option->info & OHW_R5KCVTL)
16707                     fputs (" R5KCVTL", stdout);
16708                   break;
16709
16710                 case ODK_FILL:
16711                   fputs (" FILL       ", stdout);
16712                   /* XXX Print content of info word?  */
16713                   break;
16714
16715                 case ODK_TAGS:
16716                   fputs (" TAGS       ", stdout);
16717                   /* XXX Print content of info word?  */
16718                   break;
16719
16720                 case ODK_HWAND:
16721                   fputs (" HWAND     ", stdout);
16722                   if (option->info & OHWA0_R4KEOP_CHECKED)
16723                     fputs (" R4KEOP_CHECKED", stdout);
16724                   if (option->info & OHWA0_R4KEOP_CLEAN)
16725                     fputs (" R4KEOP_CLEAN", stdout);
16726                   break;
16727
16728                 case ODK_HWOR:
16729                   fputs (" HWOR      ", stdout);
16730                   if (option->info & OHWA0_R4KEOP_CHECKED)
16731                     fputs (" R4KEOP_CHECKED", stdout);
16732                   if (option->info & OHWA0_R4KEOP_CLEAN)
16733                     fputs (" R4KEOP_CLEAN", stdout);
16734                   break;
16735
16736                 case ODK_GP_GROUP:
16737                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
16738                           option->info & OGP_GROUP,
16739                           (option->info & OGP_SELF) >> 16);
16740                   break;
16741
16742                 case ODK_IDENT:
16743                   printf (" IDENT     %#06lx  self-contained %#06lx",
16744                           option->info & OGP_GROUP,
16745                           (option->info & OGP_SELF) >> 16);
16746                   break;
16747
16748                 default:
16749                   /* This shouldn't happen.  */
16750                   printf (" %3d ???     %d %lx",
16751                           option->kind, option->section, option->info);
16752                   break;
16753                 }
16754
16755               len = sizeof (* eopt);
16756               while (len < option->size)
16757                 {
16758                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
16759
16760                   if (ISPRINT (datum))
16761                     printf ("%c", datum);
16762                   else
16763                     printf ("\\%03o", datum);
16764                   len ++;
16765                 }
16766               fputs ("\n", stdout);
16767
16768               offset += option->size;
16769               ++option;
16770             }
16771
16772           free (eopt);
16773         }
16774       else
16775         res = FALSE;
16776     }
16777
16778   if (conflicts_offset != 0 && conflictsno != 0)
16779     {
16780       Elf32_Conflict * iconf;
16781       size_t cnt;
16782
16783       if (dynamic_symbols == NULL)
16784         {
16785           error (_("conflict list found without a dynamic symbol table\n"));
16786           return FALSE;
16787         }
16788
16789       /* PR 21345 - print a slightly more helpful error message
16790          if we are sure that the cmalloc will fail.  */
16791       if (conflictsno * sizeof (* iconf) > filedata->file_size)
16792         {
16793           error (_("Overlarge number of conflicts detected: %lx\n"),
16794                  (long) conflictsno);
16795           return FALSE;
16796         }
16797
16798       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16799       if (iconf == NULL)
16800         {
16801           error (_("Out of memory allocating space for dynamic conflicts\n"));
16802           return FALSE;
16803         }
16804
16805       if (is_32bit_elf)
16806         {
16807           Elf32_External_Conflict * econf32;
16808
16809           econf32 = (Elf32_External_Conflict *)
16810               get_data (NULL, filedata, conflicts_offset, conflictsno,
16811                         sizeof (* econf32), _("conflict"));
16812           if (!econf32)
16813             return FALSE;
16814
16815           for (cnt = 0; cnt < conflictsno; ++cnt)
16816             iconf[cnt] = BYTE_GET (econf32[cnt]);
16817
16818           free (econf32);
16819         }
16820       else
16821         {
16822           Elf64_External_Conflict * econf64;
16823
16824           econf64 = (Elf64_External_Conflict *)
16825               get_data (NULL, filedata, conflicts_offset, conflictsno,
16826                         sizeof (* econf64), _("conflict"));
16827           if (!econf64)
16828             return FALSE;
16829
16830           for (cnt = 0; cnt < conflictsno; ++cnt)
16831             iconf[cnt] = BYTE_GET (econf64[cnt]);
16832
16833           free (econf64);
16834         }
16835
16836       printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16837                         "\nSection '.conflict' contains %lu entries:\n",
16838                         (unsigned long) conflictsno),
16839               (unsigned long) conflictsno);
16840       puts (_("  Num:    Index       Value  Name"));
16841
16842       for (cnt = 0; cnt < conflictsno; ++cnt)
16843         {
16844           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
16845
16846           if (iconf[cnt] >= num_dynamic_syms)
16847             printf (_("<corrupt symbol index>"));
16848           else
16849             {
16850               Elf_Internal_Sym * psym;
16851
16852               psym = & dynamic_symbols[iconf[cnt]];
16853               print_vma (psym->st_value, FULL_HEX);
16854               putchar (' ');
16855               if (VALID_DYNAMIC_NAME (psym->st_name))
16856                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16857               else
16858                 printf (_("<corrupt: %14ld>"), psym->st_name);
16859             }
16860           putchar ('\n');
16861         }
16862
16863       free (iconf);
16864     }
16865
16866   if (pltgot != 0 && local_gotno != 0)
16867     {
16868       bfd_vma ent, local_end, global_end;
16869       size_t i, offset;
16870       unsigned char * data;
16871       unsigned char * data_end;
16872       int addr_size;
16873
16874       ent = pltgot;
16875       addr_size = (is_32bit_elf ? 4 : 8);
16876       local_end = pltgot + local_gotno * addr_size;
16877
16878       /* PR binutils/17533 file: 012-111227-0.004  */
16879       if (symtabno < gotsym)
16880         {
16881           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16882                  (unsigned long) gotsym, (unsigned long) symtabno);
16883           return FALSE;
16884         }
16885
16886       global_end = local_end + (symtabno - gotsym) * addr_size;
16887       /* PR 17531: file: 54c91a34.  */
16888       if (global_end < local_end)
16889         {
16890           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
16891           return FALSE;
16892         }
16893
16894       offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
16895       data = (unsigned char *) get_data (NULL, filedata, offset,
16896                                          global_end - pltgot, 1,
16897                                          _("Global Offset Table data"));
16898       /* PR 12855: Null data is handled gracefully throughout.  */
16899       data_end = data + (global_end - pltgot);
16900
16901       printf (_("\nPrimary GOT:\n"));
16902       printf (_(" Canonical gp value: "));
16903       print_vma (pltgot + 0x7ff0, LONG_HEX);
16904       printf ("\n\n");
16905
16906       printf (_(" Reserved entries:\n"));
16907       printf (_("  %*s %10s %*s Purpose\n"),
16908               addr_size * 2, _("Address"), _("Access"),
16909               addr_size * 2, _("Initial"));
16910       ent = print_mips_got_entry (data, pltgot, ent, data_end);
16911       printf (_(" Lazy resolver\n"));
16912       if (ent == (bfd_vma) -1)
16913         goto got_print_fail;
16914
16915       /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16916          This entry will be used by some runtime loaders, to store the
16917          module pointer.  Otherwise this is an ordinary local entry.
16918          PR 21344: Check for the entry being fully available before
16919          fetching it.  */
16920       if (data
16921           && data + ent - pltgot + addr_size <= data_end
16922           && (byte_get (data + ent - pltgot, addr_size)
16923               >> (addr_size * 8 - 1)) != 0)
16924         {
16925           ent = print_mips_got_entry (data, pltgot, ent, data_end);
16926           printf (_(" Module pointer (GNU extension)\n"));
16927           if (ent == (bfd_vma) -1)
16928             goto got_print_fail;
16929         }
16930       printf ("\n");
16931
16932       if (data != NULL && ent < local_end)
16933         {
16934           printf (_(" Local entries:\n"));
16935           printf ("  %*s %10s %*s\n",
16936                   addr_size * 2, _("Address"), _("Access"),
16937                   addr_size * 2, _("Initial"));
16938           while (ent < local_end)
16939             {
16940               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16941               printf ("\n");
16942               if (ent == (bfd_vma) -1)
16943                 goto got_print_fail;
16944             }
16945           printf ("\n");
16946         }
16947
16948       if (data != NULL && gotsym < symtabno)
16949         {
16950           int sym_width;
16951
16952           printf (_(" Global entries:\n"));
16953           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
16954                   addr_size * 2, _("Address"),
16955                   _("Access"),
16956                   addr_size * 2, _("Initial"),
16957                   addr_size * 2, _("Sym.Val."),
16958                   _("Type"),
16959                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
16960                   _("Ndx"), _("Name"));
16961
16962           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
16963
16964           for (i = gotsym; i < symtabno; i++)
16965             {
16966               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16967               printf (" ");
16968
16969               if (dynamic_symbols == NULL)
16970                 printf (_("<no dynamic symbols>"));
16971               else if (i < num_dynamic_syms)
16972                 {
16973                   Elf_Internal_Sym * psym = dynamic_symbols + i;
16974
16975                   print_vma (psym->st_value, LONG_HEX);
16976                   printf (" %-7s %3s ",
16977                           get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16978                           get_symbol_index_type (filedata, psym->st_shndx));
16979
16980                   if (VALID_DYNAMIC_NAME (psym->st_name))
16981                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16982                   else
16983                     printf (_("<corrupt: %14ld>"), psym->st_name);
16984                 }
16985               else
16986                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16987                         (unsigned long) i);
16988
16989               printf ("\n");
16990               if (ent == (bfd_vma) -1)
16991                 break;
16992             }
16993           printf ("\n");
16994         }
16995
16996     got_print_fail:
16997       if (data)
16998         free (data);
16999     }
17000
17001   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
17002     {
17003       bfd_vma ent, end;
17004       size_t offset, rel_offset;
17005       unsigned long count, i;
17006       unsigned char * data;
17007       int addr_size, sym_width;
17008       Elf_Internal_Rela * rels;
17009
17010       rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
17011       if (pltrel == DT_RELA)
17012         {
17013           if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
17014             return FALSE;
17015         }
17016       else
17017         {
17018           if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
17019             return FALSE;
17020         }
17021
17022       ent = mips_pltgot;
17023       addr_size = (is_32bit_elf ? 4 : 8);
17024       end = mips_pltgot + (2 + count) * addr_size;
17025
17026       offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
17027       data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
17028                                          1, _("Procedure Linkage Table data"));
17029       if (data == NULL)
17030         return FALSE;
17031
17032       printf ("\nPLT GOT:\n\n");
17033       printf (_(" Reserved entries:\n"));
17034       printf (_("  %*s %*s Purpose\n"),
17035               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
17036       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
17037       printf (_(" PLT lazy resolver\n"));
17038       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
17039       printf (_(" Module pointer\n"));
17040       printf ("\n");
17041
17042       printf (_(" Entries:\n"));
17043       printf ("  %*s %*s %*s %-7s %3s %s\n",
17044               addr_size * 2, _("Address"),
17045               addr_size * 2, _("Initial"),
17046               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17047       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
17048       for (i = 0; i < count; i++)
17049         {
17050           unsigned long idx = get_reloc_symindex (rels[i].r_info);
17051
17052           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
17053           printf (" ");
17054
17055           if (idx >= num_dynamic_syms)
17056             printf (_("<corrupt symbol index: %lu>"), idx);
17057           else
17058             {
17059               Elf_Internal_Sym * psym = dynamic_symbols + idx;
17060
17061               print_vma (psym->st_value, LONG_HEX);
17062               printf (" %-7s %3s ",
17063                       get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
17064                       get_symbol_index_type (filedata, psym->st_shndx));
17065               if (VALID_DYNAMIC_NAME (psym->st_name))
17066                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
17067               else
17068                 printf (_("<corrupt: %14ld>"), psym->st_name);
17069             }
17070           printf ("\n");
17071         }
17072       printf ("\n");
17073
17074       if (data)
17075         free (data);
17076       free (rels);
17077     }
17078
17079   return res;
17080 }
17081
17082 static bfd_boolean
17083 process_nds32_specific (Filedata * filedata)
17084 {
17085   Elf_Internal_Shdr *sect = NULL;
17086
17087   sect = find_section (filedata, ".nds32_e_flags");
17088   if (sect != NULL)
17089     {
17090       unsigned int *flag;
17091
17092       printf ("\nNDS32 elf flags section:\n");
17093       flag = get_data (NULL, filedata, sect->sh_offset, 1,
17094                        sect->sh_size, _("NDS32 elf flags section"));
17095
17096       if (! flag)
17097         return FALSE;
17098
17099       switch ((*flag) & 0x3)
17100         {
17101         case 0:
17102           printf ("(VEC_SIZE):\tNo entry.\n");
17103           break;
17104         case 1:
17105           printf ("(VEC_SIZE):\t4 bytes\n");
17106           break;
17107         case 2:
17108           printf ("(VEC_SIZE):\t16 bytes\n");
17109           break;
17110         case 3:
17111           printf ("(VEC_SIZE):\treserved\n");
17112           break;
17113         }
17114     }
17115
17116   return TRUE;
17117 }
17118
17119 static bfd_boolean
17120 process_gnu_liblist (Filedata * filedata)
17121 {
17122   Elf_Internal_Shdr * section;
17123   Elf_Internal_Shdr * string_sec;
17124   Elf32_External_Lib * elib;
17125   char * strtab;
17126   size_t strtab_size;
17127   size_t cnt;
17128   unsigned long num_liblist;
17129   unsigned i;
17130   bfd_boolean res = TRUE;
17131
17132   if (! do_arch)
17133     return TRUE;
17134
17135   for (i = 0, section = filedata->section_headers;
17136        i < filedata->file_header.e_shnum;
17137        i++, section++)
17138     {
17139       switch (section->sh_type)
17140         {
17141         case SHT_GNU_LIBLIST:
17142           if (section->sh_link >= filedata->file_header.e_shnum)
17143             break;
17144
17145           elib = (Elf32_External_Lib *)
17146               get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
17147                         _("liblist section data"));
17148
17149           if (elib == NULL)
17150             {
17151               res = FALSE;
17152               break;
17153             }
17154
17155           string_sec = filedata->section_headers + section->sh_link;
17156           strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
17157                                       string_sec->sh_size,
17158                                       _("liblist string table"));
17159           if (strtab == NULL
17160               || section->sh_entsize != sizeof (Elf32_External_Lib))
17161             {
17162               free (elib);
17163               free (strtab);
17164               res = FALSE;
17165               break;
17166             }
17167           strtab_size = string_sec->sh_size;
17168
17169           num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
17170           printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17171                             "\nLibrary list section '%s' contains %lu entries:\n",
17172                             num_liblist),
17173                   printable_section_name (filedata, section),
17174                   num_liblist);
17175
17176           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
17177
17178           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
17179                ++cnt)
17180             {
17181               Elf32_Lib liblist;
17182               time_t atime;
17183               char timebuf[128];
17184               struct tm * tmp;
17185
17186               liblist.l_name = BYTE_GET (elib[cnt].l_name);
17187               atime = BYTE_GET (elib[cnt].l_time_stamp);
17188               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
17189               liblist.l_version = BYTE_GET (elib[cnt].l_version);
17190               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
17191
17192               tmp = gmtime (&atime);
17193               snprintf (timebuf, sizeof (timebuf),
17194                         "%04u-%02u-%02uT%02u:%02u:%02u",
17195                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
17196                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
17197
17198               printf ("%3lu: ", (unsigned long) cnt);
17199               if (do_wide)
17200                 printf ("%-20s", liblist.l_name < strtab_size
17201                         ? strtab + liblist.l_name : _("<corrupt>"));
17202               else
17203                 printf ("%-20.20s", liblist.l_name < strtab_size
17204                         ? strtab + liblist.l_name : _("<corrupt>"));
17205               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
17206                       liblist.l_version, liblist.l_flags);
17207             }
17208
17209           free (elib);
17210           free (strtab);
17211         }
17212     }
17213
17214   return res;
17215 }
17216
17217 static const char *
17218 get_note_type (Filedata * filedata, unsigned e_type)
17219 {
17220   static char buff[64];
17221
17222   if (filedata->file_header.e_type == ET_CORE)
17223     switch (e_type)
17224       {
17225       case NT_AUXV:
17226         return _("NT_AUXV (auxiliary vector)");
17227       case NT_PRSTATUS:
17228         return _("NT_PRSTATUS (prstatus structure)");
17229       case NT_FPREGSET:
17230         return _("NT_FPREGSET (floating point registers)");
17231       case NT_PRPSINFO:
17232         return _("NT_PRPSINFO (prpsinfo structure)");
17233       case NT_TASKSTRUCT:
17234         return _("NT_TASKSTRUCT (task structure)");
17235       case NT_PRXFPREG:
17236         return _("NT_PRXFPREG (user_xfpregs structure)");
17237       case NT_PPC_VMX:
17238         return _("NT_PPC_VMX (ppc Altivec registers)");
17239       case NT_PPC_VSX:
17240         return _("NT_PPC_VSX (ppc VSX registers)");
17241       case NT_PPC_TAR:
17242         return _("NT_PPC_TAR (ppc TAR register)");
17243       case NT_PPC_PPR:
17244         return _("NT_PPC_PPR (ppc PPR register)");
17245       case NT_PPC_DSCR:
17246         return _("NT_PPC_DSCR (ppc DSCR register)");
17247       case NT_PPC_EBB:
17248         return _("NT_PPC_EBB (ppc EBB registers)");
17249       case NT_PPC_PMU:
17250         return _("NT_PPC_PMU (ppc PMU registers)");
17251       case NT_PPC_TM_CGPR:
17252         return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17253       case NT_PPC_TM_CFPR:
17254         return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17255       case NT_PPC_TM_CVMX:
17256         return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17257       case NT_PPC_TM_CVSX:
17258         return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17259       case NT_PPC_TM_SPR:
17260         return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17261       case NT_PPC_TM_CTAR:
17262         return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17263       case NT_PPC_TM_CPPR:
17264         return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17265       case NT_PPC_TM_CDSCR:
17266         return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17267       case NT_386_TLS:
17268         return _("NT_386_TLS (x86 TLS information)");
17269       case NT_386_IOPERM:
17270         return _("NT_386_IOPERM (x86 I/O permissions)");
17271       case NT_X86_XSTATE:
17272         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17273       case NT_S390_HIGH_GPRS:
17274         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17275       case NT_S390_TIMER:
17276         return _("NT_S390_TIMER (s390 timer register)");
17277       case NT_S390_TODCMP:
17278         return _("NT_S390_TODCMP (s390 TOD comparator register)");
17279       case NT_S390_TODPREG:
17280         return _("NT_S390_TODPREG (s390 TOD programmable register)");
17281       case NT_S390_CTRS:
17282         return _("NT_S390_CTRS (s390 control registers)");
17283       case NT_S390_PREFIX:
17284         return _("NT_S390_PREFIX (s390 prefix register)");
17285       case NT_S390_LAST_BREAK:
17286         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17287       case NT_S390_SYSTEM_CALL:
17288         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17289       case NT_S390_TDB:
17290         return _("NT_S390_TDB (s390 transaction diagnostic block)");
17291       case NT_S390_VXRS_LOW:
17292         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17293       case NT_S390_VXRS_HIGH:
17294         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17295       case NT_S390_GS_CB:
17296         return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17297       case NT_S390_GS_BC:
17298         return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17299       case NT_ARM_VFP:
17300         return _("NT_ARM_VFP (arm VFP registers)");
17301       case NT_ARM_TLS:
17302         return _("NT_ARM_TLS (AArch TLS registers)");
17303       case NT_ARM_HW_BREAK:
17304         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17305       case NT_ARM_HW_WATCH:
17306         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17307       case NT_PSTATUS:
17308         return _("NT_PSTATUS (pstatus structure)");
17309       case NT_FPREGS:
17310         return _("NT_FPREGS (floating point registers)");
17311       case NT_PSINFO:
17312         return _("NT_PSINFO (psinfo structure)");
17313       case NT_LWPSTATUS:
17314         return _("NT_LWPSTATUS (lwpstatus_t structure)");
17315       case NT_LWPSINFO:
17316         return _("NT_LWPSINFO (lwpsinfo_t structure)");
17317       case NT_WIN32PSTATUS:
17318         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17319       case NT_SIGINFO:
17320         return _("NT_SIGINFO (siginfo_t data)");
17321       case NT_FILE:
17322         return _("NT_FILE (mapped files)");
17323       default:
17324         break;
17325       }
17326   else
17327     switch (e_type)
17328       {
17329       case NT_VERSION:
17330         return _("NT_VERSION (version)");
17331       case NT_ARCH:
17332         return _("NT_ARCH (architecture)");
17333       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
17334         return _("OPEN");
17335       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
17336         return _("func");
17337       default:
17338         break;
17339       }
17340
17341   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17342   return buff;
17343 }
17344
17345 static bfd_boolean
17346 print_core_note (Elf_Internal_Note *pnote)
17347 {
17348   unsigned int addr_size = is_32bit_elf ? 4 : 8;
17349   bfd_vma count, page_size;
17350   unsigned char *descdata, *filenames, *descend;
17351
17352   if (pnote->type != NT_FILE)
17353     {
17354       if (do_wide)
17355         printf ("\n");
17356       return TRUE;
17357     }
17358
17359 #ifndef BFD64
17360   if (!is_32bit_elf)
17361     {
17362       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
17363       /* Still "successful".  */
17364       return TRUE;
17365     }
17366 #endif
17367
17368   if (pnote->descsz < 2 * addr_size)
17369     {
17370       error (_("    Malformed note - too short for header\n"));
17371       return FALSE;
17372     }
17373
17374   descdata = (unsigned char *) pnote->descdata;
17375   descend = descdata + pnote->descsz;
17376
17377   if (descdata[pnote->descsz - 1] != '\0')
17378     {
17379       error (_("    Malformed note - does not end with \\0\n"));
17380       return FALSE;
17381     }
17382
17383   count = byte_get (descdata, addr_size);
17384   descdata += addr_size;
17385
17386   page_size = byte_get (descdata, addr_size);
17387   descdata += addr_size;
17388
17389   if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
17390       || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
17391     {
17392       error (_("    Malformed note - too short for supplied file count\n"));
17393       return FALSE;
17394     }
17395
17396   printf (_("    Page size: "));
17397   print_vma (page_size, DEC);
17398   printf ("\n");
17399
17400   printf (_("    %*s%*s%*s\n"),
17401           (int) (2 + 2 * addr_size), _("Start"),
17402           (int) (4 + 2 * addr_size), _("End"),
17403           (int) (4 + 2 * addr_size), _("Page Offset"));
17404   filenames = descdata + count * 3 * addr_size;
17405   while (count-- > 0)
17406     {
17407       bfd_vma start, end, file_ofs;
17408
17409       if (filenames == descend)
17410         {
17411           error (_("    Malformed note - filenames end too early\n"));
17412           return FALSE;
17413         }
17414
17415       start = byte_get (descdata, addr_size);
17416       descdata += addr_size;
17417       end = byte_get (descdata, addr_size);
17418       descdata += addr_size;
17419       file_ofs = byte_get (descdata, addr_size);
17420       descdata += addr_size;
17421
17422       printf ("    ");
17423       print_vma (start, FULL_HEX);
17424       printf ("  ");
17425       print_vma (end, FULL_HEX);
17426       printf ("  ");
17427       print_vma (file_ofs, FULL_HEX);
17428       printf ("\n        %s\n", filenames);
17429
17430       filenames += 1 + strlen ((char *) filenames);
17431     }
17432
17433   return TRUE;
17434 }
17435
17436 static const char *
17437 get_gnu_elf_note_type (unsigned e_type)
17438 {
17439   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
17440   switch (e_type)
17441     {
17442     case NT_GNU_ABI_TAG:
17443       return _("NT_GNU_ABI_TAG (ABI version tag)");
17444     case NT_GNU_HWCAP:
17445       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17446     case NT_GNU_BUILD_ID:
17447       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17448     case NT_GNU_GOLD_VERSION:
17449       return _("NT_GNU_GOLD_VERSION (gold version)");
17450     case NT_GNU_PROPERTY_TYPE_0:
17451       return _("NT_GNU_PROPERTY_TYPE_0");
17452     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
17453       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17454     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
17455       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17456     default:
17457       {
17458         static char buff[64];
17459
17460         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17461         return buff;
17462       }
17463     }
17464 }
17465
17466 static void
17467 decode_x86_compat_isa (unsigned int bitmask)
17468 {
17469   while (bitmask)
17470     {
17471       unsigned int bit = bitmask & (- bitmask);
17472
17473       bitmask &= ~ bit;
17474       switch (bit)
17475         {
17476         case GNU_PROPERTY_X86_COMPAT_ISA_1_486:
17477           printf ("i486");
17478           break;
17479         case GNU_PROPERTY_X86_COMPAT_ISA_1_586:
17480           printf ("586");
17481           break;
17482         case GNU_PROPERTY_X86_COMPAT_ISA_1_686:
17483           printf ("686");
17484           break;
17485         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE:
17486           printf ("SSE");
17487           break;
17488         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2:
17489           printf ("SSE2");
17490           break;
17491         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3:
17492           printf ("SSE3");
17493           break;
17494         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3:
17495           printf ("SSSE3");
17496           break;
17497         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1:
17498           printf ("SSE4_1");
17499           break;
17500         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2:
17501           printf ("SSE4_2");
17502           break;
17503         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX:
17504           printf ("AVX");
17505           break;
17506         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2:
17507           printf ("AVX2");
17508           break;
17509         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F:
17510           printf ("AVX512F");
17511           break;
17512         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD:
17513           printf ("AVX512CD");
17514           break;
17515         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER:
17516           printf ("AVX512ER");
17517           break;
17518         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF:
17519           printf ("AVX512PF");
17520           break;
17521         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL:
17522           printf ("AVX512VL");
17523           break;
17524         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ:
17525           printf ("AVX512DQ");
17526           break;
17527         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW:
17528           printf ("AVX512BW");
17529           break;
17530         default:
17531           printf (_("<unknown: %x>"), bit);
17532           break;
17533         }
17534       if (bitmask)
17535         printf (", ");
17536     }
17537 }
17538
17539 static void
17540 decode_x86_isa (unsigned int bitmask)
17541 {
17542   if (!bitmask)
17543     {
17544       printf (_("<None>"));
17545       return;
17546     }
17547
17548   while (bitmask)
17549     {
17550       unsigned int bit = bitmask & (- bitmask);
17551
17552       bitmask &= ~ bit;
17553       switch (bit)
17554         {
17555         case GNU_PROPERTY_X86_ISA_1_CMOV:
17556           printf ("CMOV");
17557           break;
17558         case GNU_PROPERTY_X86_ISA_1_SSE:
17559           printf ("SSE");
17560           break;
17561         case GNU_PROPERTY_X86_ISA_1_SSE2:
17562           printf ("SSE2");
17563           break;
17564         case GNU_PROPERTY_X86_ISA_1_SSE3:
17565           printf ("SSE3");
17566           break;
17567         case GNU_PROPERTY_X86_ISA_1_SSSE3:
17568           printf ("SSSE3");
17569           break;
17570         case GNU_PROPERTY_X86_ISA_1_SSE4_1:
17571           printf ("SSE4_1");
17572           break;
17573         case GNU_PROPERTY_X86_ISA_1_SSE4_2:
17574           printf ("SSE4_2");
17575           break;
17576         case GNU_PROPERTY_X86_ISA_1_AVX:
17577           printf ("AVX");
17578           break;
17579         case GNU_PROPERTY_X86_ISA_1_AVX2:
17580           printf ("AVX2");
17581           break;
17582         case GNU_PROPERTY_X86_ISA_1_FMA:
17583           printf ("FMA");
17584           break;
17585         case GNU_PROPERTY_X86_ISA_1_AVX512F:
17586           printf ("AVX512F");
17587           break;
17588         case GNU_PROPERTY_X86_ISA_1_AVX512CD:
17589           printf ("AVX512CD");
17590           break;
17591         case GNU_PROPERTY_X86_ISA_1_AVX512ER:
17592           printf ("AVX512ER");
17593           break;
17594         case GNU_PROPERTY_X86_ISA_1_AVX512PF:
17595           printf ("AVX512PF");
17596           break;
17597         case GNU_PROPERTY_X86_ISA_1_AVX512VL:
17598           printf ("AVX512VL");
17599           break;
17600         case GNU_PROPERTY_X86_ISA_1_AVX512DQ:
17601           printf ("AVX512DQ");
17602           break;
17603         case GNU_PROPERTY_X86_ISA_1_AVX512BW:
17604           printf ("AVX512BW");
17605           break;
17606         case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS:
17607           printf ("AVX512_4FMAPS");
17608           break;
17609         case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW:
17610           printf ("AVX512_4VNNIW");
17611           break;
17612         case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG:
17613           printf ("AVX512_BITALG");
17614           break;
17615         case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA:
17616           printf ("AVX512_IFMA");
17617           break;
17618         case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI:
17619           printf ("AVX512_VBMI");
17620           break;
17621         case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2:
17622           printf ("AVX512_VBMI2");
17623           break;
17624         case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI:
17625           printf ("AVX512_VNNI");
17626           break;
17627         case GNU_PROPERTY_X86_ISA_1_AVX512_BF16:
17628           printf ("AVX512_BF16");
17629           break;
17630         default:
17631           printf (_("<unknown: %x>"), bit);
17632           break;
17633         }
17634       if (bitmask)
17635         printf (", ");
17636     }
17637 }
17638
17639 static void
17640 decode_x86_feature_1 (unsigned int bitmask)
17641 {
17642   if (!bitmask)
17643     {
17644       printf (_("<None>"));
17645       return;
17646     }
17647
17648   while (bitmask)
17649     {
17650       unsigned int bit = bitmask & (- bitmask);
17651
17652       bitmask &= ~ bit;
17653       switch (bit)
17654         {
17655         case GNU_PROPERTY_X86_FEATURE_1_IBT:
17656           printf ("IBT");
17657           break;
17658         case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
17659           printf ("SHSTK");
17660           break;
17661         default:
17662           printf (_("<unknown: %x>"), bit);
17663           break;
17664         }
17665       if (bitmask)
17666         printf (", ");
17667     }
17668 }
17669
17670 static void
17671 decode_x86_feature_2 (unsigned int bitmask)
17672 {
17673   if (!bitmask)
17674     {
17675       printf (_("<None>"));
17676       return;
17677     }
17678
17679   while (bitmask)
17680     {
17681       unsigned int bit = bitmask & (- bitmask);
17682
17683       bitmask &= ~ bit;
17684       switch (bit)
17685         {
17686         case GNU_PROPERTY_X86_FEATURE_2_X86:
17687           printf ("x86");
17688           break;
17689         case GNU_PROPERTY_X86_FEATURE_2_X87:
17690           printf ("x87");
17691           break;
17692         case GNU_PROPERTY_X86_FEATURE_2_MMX:
17693           printf ("MMX");
17694           break;
17695         case GNU_PROPERTY_X86_FEATURE_2_XMM:
17696           printf ("XMM");
17697           break;
17698         case GNU_PROPERTY_X86_FEATURE_2_YMM:
17699           printf ("YMM");
17700           break;
17701         case GNU_PROPERTY_X86_FEATURE_2_ZMM:
17702           printf ("ZMM");
17703           break;
17704         case GNU_PROPERTY_X86_FEATURE_2_FXSR:
17705           printf ("FXSR");
17706           break;
17707         case GNU_PROPERTY_X86_FEATURE_2_XSAVE:
17708           printf ("XSAVE");
17709           break;
17710         case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT:
17711           printf ("XSAVEOPT");
17712           break;
17713         case GNU_PROPERTY_X86_FEATURE_2_XSAVEC:
17714           printf ("XSAVEC");
17715           break;
17716         default:
17717           printf (_("<unknown: %x>"), bit);
17718           break;
17719         }
17720       if (bitmask)
17721         printf (", ");
17722     }
17723 }
17724
17725 static void
17726 decode_aarch64_feature_1_and (unsigned int bitmask)
17727 {
17728   while (bitmask)
17729     {
17730       unsigned int bit = bitmask & (- bitmask);
17731
17732       bitmask &= ~ bit;
17733       switch (bit)
17734         {
17735         case GNU_PROPERTY_AARCH64_FEATURE_1_BTI:
17736           printf ("BTI");
17737           break;
17738
17739         case GNU_PROPERTY_AARCH64_FEATURE_1_PAC:
17740           printf ("PAC");
17741           break;
17742
17743         default:
17744           printf (_("<unknown: %x>"), bit);
17745           break;
17746         }
17747       if (bitmask)
17748         printf (", ");
17749     }
17750 }
17751
17752 static void
17753 print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
17754 {
17755   unsigned char * ptr = (unsigned char *) pnote->descdata;
17756   unsigned char * ptr_end = ptr + pnote->descsz;
17757   unsigned int    size = is_32bit_elf ? 4 : 8;
17758
17759   printf (_("      Properties: "));
17760
17761   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
17762     {
17763       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
17764       return;
17765     }
17766
17767   while (ptr < ptr_end)
17768     {
17769       unsigned int j;
17770       unsigned int type;
17771       unsigned int datasz;
17772
17773       if ((size_t) (ptr_end - ptr) < 8)
17774         {
17775           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
17776           break;
17777         }
17778
17779       type = byte_get (ptr, 4);
17780       datasz = byte_get (ptr + 4, 4);
17781
17782       ptr += 8;
17783
17784       if (datasz > (size_t) (ptr_end - ptr))
17785         {
17786           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17787                   type, datasz);
17788           break;
17789         }
17790
17791       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
17792         {
17793           if (filedata->file_header.e_machine == EM_X86_64
17794               || filedata->file_header.e_machine == EM_IAMCU
17795               || filedata->file_header.e_machine == EM_386)
17796             {
17797               unsigned int bitmask;
17798
17799               if (datasz == 4)
17800                 bitmask = byte_get (ptr, 4);
17801               else
17802                 bitmask = 0;
17803
17804               switch (type)
17805                 {
17806                 case GNU_PROPERTY_X86_ISA_1_USED:
17807                   if (datasz != 4)
17808                     printf (_("x86 ISA used: <corrupt length: %#x> "),
17809                             datasz);
17810                   else
17811                     {
17812                       printf ("x86 ISA used: ");
17813                       decode_x86_isa (bitmask);
17814                     }
17815                   goto next;
17816
17817                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
17818                   if (datasz != 4)
17819                     printf (_("x86 ISA needed: <corrupt length: %#x> "),
17820                             datasz);
17821                   else
17822                     {
17823                       printf ("x86 ISA needed: ");
17824                       decode_x86_isa (bitmask);
17825                     }
17826                   goto next;
17827
17828                 case GNU_PROPERTY_X86_FEATURE_1_AND:
17829                   if (datasz != 4)
17830                     printf (_("x86 feature: <corrupt length: %#x> "),
17831                             datasz);
17832                   else
17833                     {
17834                       printf ("x86 feature: ");
17835                       decode_x86_feature_1 (bitmask);
17836                     }
17837                   goto next;
17838
17839                 case GNU_PROPERTY_X86_FEATURE_2_USED:
17840                   if (datasz != 4)
17841                     printf (_("x86 feature used: <corrupt length: %#x> "),
17842                             datasz);
17843                   else
17844                     {
17845                       printf ("x86 feature used: ");
17846                       decode_x86_feature_2 (bitmask);
17847                     }
17848                   goto next;
17849
17850                 case GNU_PROPERTY_X86_FEATURE_2_NEEDED:
17851                   if (datasz != 4)
17852                     printf (_("x86 feature needed: <corrupt length: %#x> "), datasz);
17853                   else
17854                     {
17855                       printf ("x86 feature needed: ");
17856                       decode_x86_feature_2 (bitmask);
17857                     }
17858                   goto next;
17859
17860                 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED:
17861                   if (datasz != 4)
17862                     printf (_("x86 ISA used: <corrupt length: %#x> "),
17863                             datasz);
17864                   else
17865                     {
17866                       printf ("x86 ISA used: ");
17867                       decode_x86_compat_isa (bitmask);
17868                     }
17869                   goto next;
17870
17871                 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED:
17872                   if (datasz != 4)
17873                     printf (_("x86 ISA needed: <corrupt length: %#x> "),
17874                             datasz);
17875                   else
17876                     {
17877                       printf ("x86 ISA needed: ");
17878                       decode_x86_compat_isa (bitmask);
17879                     }
17880                   goto next;
17881
17882                 default:
17883                   break;
17884                 }
17885             }
17886           else if (filedata->file_header.e_machine == EM_AARCH64)
17887             {
17888               if (type == GNU_PROPERTY_AARCH64_FEATURE_1_AND)
17889                 {
17890                   printf ("AArch64 feature: ");
17891                   if (datasz != 4)
17892                     printf (_("<corrupt length: %#x> "), datasz);
17893                   else
17894                     decode_aarch64_feature_1_and (byte_get (ptr, 4));
17895                   goto next;
17896                 }
17897             }
17898         }
17899       else
17900         {
17901           switch (type)
17902             {
17903             case GNU_PROPERTY_STACK_SIZE:
17904               printf (_("stack size: "));
17905               if (datasz != size)
17906                 printf (_("<corrupt length: %#x> "), datasz);
17907               else
17908                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
17909               goto next;
17910
17911             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
17912               printf ("no copy on protected ");
17913               if (datasz)
17914                 printf (_("<corrupt length: %#x> "), datasz);
17915               goto next;
17916
17917             default:
17918               break;
17919             }
17920         }
17921
17922       if (type < GNU_PROPERTY_LOPROC)
17923         printf (_("<unknown type %#x data: "), type);
17924       else if (type < GNU_PROPERTY_LOUSER)
17925         printf (_("<procesor-specific type %#x data: "), type);
17926       else
17927         printf (_("<application-specific type %#x data: "), type);
17928       for (j = 0; j < datasz; ++j)
17929         printf ("%02x ", ptr[j] & 0xff);
17930       printf (">");
17931
17932 next:
17933       ptr += ((datasz + (size - 1)) & ~ (size - 1));
17934       if (ptr == ptr_end)
17935         break;
17936
17937       if (do_wide)
17938         printf (", ");
17939       else
17940         printf ("\n\t");
17941     }
17942
17943   printf ("\n");
17944 }
17945
17946 static bfd_boolean
17947 print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
17948 {
17949   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
17950   switch (pnote->type)
17951     {
17952     case NT_GNU_BUILD_ID:
17953       {
17954         unsigned long i;
17955
17956         printf (_("    Build ID: "));
17957         for (i = 0; i < pnote->descsz; ++i)
17958           printf ("%02x", pnote->descdata[i] & 0xff);
17959         printf ("\n");
17960       }
17961       break;
17962
17963     case NT_GNU_ABI_TAG:
17964       {
17965         unsigned long os, major, minor, subminor;
17966         const char *osname;
17967
17968         /* PR 17531: file: 030-599401-0.004.  */
17969         if (pnote->descsz < 16)
17970           {
17971             printf (_("    <corrupt GNU_ABI_TAG>\n"));
17972             break;
17973           }
17974
17975         os = byte_get ((unsigned char *) pnote->descdata, 4);
17976         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17977         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
17978         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
17979
17980         switch (os)
17981           {
17982           case GNU_ABI_TAG_LINUX:
17983             osname = "Linux";
17984             break;
17985           case GNU_ABI_TAG_HURD:
17986             osname = "Hurd";
17987             break;
17988           case GNU_ABI_TAG_SOLARIS:
17989             osname = "Solaris";
17990             break;
17991           case GNU_ABI_TAG_FREEBSD:
17992             osname = "FreeBSD";
17993             break;
17994           case GNU_ABI_TAG_NETBSD:
17995             osname = "NetBSD";
17996             break;
17997           case GNU_ABI_TAG_SYLLABLE:
17998             osname = "Syllable";
17999             break;
18000           case GNU_ABI_TAG_NACL:
18001             osname = "NaCl";
18002             break;
18003           default:
18004             osname = "Unknown";
18005             break;
18006           }
18007
18008         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
18009                 major, minor, subminor);
18010       }
18011       break;
18012
18013     case NT_GNU_GOLD_VERSION:
18014       {
18015         unsigned long i;
18016
18017         printf (_("    Version: "));
18018         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
18019           printf ("%c", pnote->descdata[i]);
18020         printf ("\n");
18021       }
18022       break;
18023
18024     case NT_GNU_HWCAP:
18025       {
18026         unsigned long num_entries, mask;
18027
18028         /* Hardware capabilities information.  Word 0 is the number of entries.
18029            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
18030            is a series of entries, where each entry is a single byte followed
18031            by a nul terminated string.  The byte gives the bit number to test
18032            if enabled in the bitmask.  */
18033         printf (_("      Hardware Capabilities: "));
18034         if (pnote->descsz < 8)
18035           {
18036             error (_("<corrupt GNU_HWCAP>\n"));
18037             return FALSE;
18038           }
18039         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
18040         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18041         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
18042         /* FIXME: Add code to display the entries... */
18043       }
18044       break;
18045
18046     case NT_GNU_PROPERTY_TYPE_0:
18047       print_gnu_property_note (filedata, pnote);
18048       break;
18049
18050     default:
18051       /* Handle unrecognised types.  An error message should have already been
18052          created by get_gnu_elf_note_type(), so all that we need to do is to
18053          display the data.  */
18054       {
18055         unsigned long i;
18056
18057         printf (_("    Description data: "));
18058         for (i = 0; i < pnote->descsz; ++i)
18059           printf ("%02x ", pnote->descdata[i] & 0xff);
18060         printf ("\n");
18061       }
18062       break;
18063     }
18064
18065   return TRUE;
18066 }
18067
18068 static const char *
18069 get_v850_elf_note_type (enum v850_notes n_type)
18070 {
18071   static char buff[64];
18072
18073   switch (n_type)
18074     {
18075     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
18076     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
18077     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
18078     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
18079     case V850_NOTE_CACHE_INFO: return _("Use of cache");
18080     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
18081     default:
18082       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
18083       return buff;
18084     }
18085 }
18086
18087 static bfd_boolean
18088 print_v850_note (Elf_Internal_Note * pnote)
18089 {
18090   unsigned int val;
18091
18092   if (pnote->descsz != 4)
18093     return FALSE;
18094
18095   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
18096
18097   if (val == 0)
18098     {
18099       printf (_("not set\n"));
18100       return TRUE;
18101     }
18102
18103   switch (pnote->type)
18104     {
18105     case V850_NOTE_ALIGNMENT:
18106       switch (val)
18107         {
18108         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
18109         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
18110         }
18111       break;
18112
18113     case V850_NOTE_DATA_SIZE:
18114       switch (val)
18115         {
18116         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
18117         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
18118         }
18119       break;
18120
18121     case V850_NOTE_FPU_INFO:
18122       switch (val)
18123         {
18124         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
18125         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
18126         }
18127       break;
18128
18129     case V850_NOTE_MMU_INFO:
18130     case V850_NOTE_CACHE_INFO:
18131     case V850_NOTE_SIMD_INFO:
18132       if (val == EF_RH850_SIMD)
18133         {
18134           printf (_("yes\n"));
18135           return TRUE;
18136         }
18137       break;
18138
18139     default:
18140       /* An 'unknown note type' message will already have been displayed.  */
18141       break;
18142     }
18143
18144   printf (_("unknown value: %x\n"), val);
18145   return FALSE;
18146 }
18147
18148 static bfd_boolean
18149 process_netbsd_elf_note (Elf_Internal_Note * pnote)
18150 {
18151   unsigned int version;
18152
18153   switch (pnote->type)
18154     {
18155     case NT_NETBSD_IDENT:
18156       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
18157       if ((version / 10000) % 100)
18158         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
18159                 version, version / 100000000, (version / 1000000) % 100,
18160                 (version / 10000) % 100 > 26 ? "Z" : "",
18161                 'A' + (version / 10000) % 26);
18162       else
18163         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
18164                 version, version / 100000000, (version / 1000000) % 100,
18165                 (version / 100) % 100);
18166       return TRUE;
18167
18168     case NT_NETBSD_MARCH:
18169       printf ("  NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
18170               pnote->descdata);
18171       return TRUE;
18172
18173 #ifdef   NT_NETBSD_PAX
18174     case NT_NETBSD_PAX:
18175       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
18176       printf ("  NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote->descsz,
18177               ((version & NT_NETBSD_PAX_MPROTECT) ? "+mprotect" : ""),
18178               ((version & NT_NETBSD_PAX_NOMPROTECT) ? "-mprotect" : ""),
18179               ((version & NT_NETBSD_PAX_GUARD) ? "+guard" : ""),
18180               ((version & NT_NETBSD_PAX_NOGUARD) ? "-guard" : ""),
18181               ((version & NT_NETBSD_PAX_ASLR) ? "+ASLR" : ""),
18182               ((version & NT_NETBSD_PAX_NOASLR) ? "-ASLR" : ""));
18183       return TRUE;
18184 #endif
18185
18186     default:
18187       printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
18188               pnote->type);
18189       return FALSE;
18190     }
18191 }
18192
18193 static const char *
18194 get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
18195 {
18196   switch (e_type)
18197     {
18198     case NT_FREEBSD_THRMISC:
18199       return _("NT_THRMISC (thrmisc structure)");
18200     case NT_FREEBSD_PROCSTAT_PROC:
18201       return _("NT_PROCSTAT_PROC (proc data)");
18202     case NT_FREEBSD_PROCSTAT_FILES:
18203       return _("NT_PROCSTAT_FILES (files data)");
18204     case NT_FREEBSD_PROCSTAT_VMMAP:
18205       return _("NT_PROCSTAT_VMMAP (vmmap data)");
18206     case NT_FREEBSD_PROCSTAT_GROUPS:
18207       return _("NT_PROCSTAT_GROUPS (groups data)");
18208     case NT_FREEBSD_PROCSTAT_UMASK:
18209       return _("NT_PROCSTAT_UMASK (umask data)");
18210     case NT_FREEBSD_PROCSTAT_RLIMIT:
18211       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18212     case NT_FREEBSD_PROCSTAT_OSREL:
18213       return _("NT_PROCSTAT_OSREL (osreldate data)");
18214     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
18215       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18216     case NT_FREEBSD_PROCSTAT_AUXV:
18217       return _("NT_PROCSTAT_AUXV (auxv data)");
18218     case NT_FREEBSD_PTLWPINFO:
18219       return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18220     }
18221   return get_note_type (filedata, e_type);
18222 }
18223
18224 static const char *
18225 get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
18226 {
18227   static char buff[64];
18228
18229   switch (e_type)
18230     {
18231     case NT_NETBSDCORE_PROCINFO:
18232       /* NetBSD core "procinfo" structure.  */
18233       return _("NetBSD procinfo structure");
18234
18235 #ifdef NT_NETBSDCORE_AUXV
18236     case NT_NETBSDCORE_AUXV:
18237       return _("NetBSD ELF auxiliary vector data");
18238 #endif
18239
18240     default:
18241       /* As of Jan 2002 there are no other machine-independent notes
18242          defined for NetBSD core files.  If the note type is less
18243          than the start of the machine-dependent note types, we don't
18244          understand it.  */
18245
18246       if (e_type < NT_NETBSDCORE_FIRSTMACH)
18247         {
18248           snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18249           return buff;
18250         }
18251       break;
18252     }
18253
18254   switch (filedata->file_header.e_machine)
18255     {
18256     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18257        and PT_GETFPREGS == mach+2.  */
18258
18259     case EM_OLD_ALPHA:
18260     case EM_ALPHA:
18261     case EM_SPARC:
18262     case EM_SPARC32PLUS:
18263     case EM_SPARCV9:
18264       switch (e_type)
18265         {
18266         case NT_NETBSDCORE_FIRSTMACH + 0:
18267           return _("PT_GETREGS (reg structure)");
18268         case NT_NETBSDCORE_FIRSTMACH + 2:
18269           return _("PT_GETFPREGS (fpreg structure)");
18270         default:
18271           break;
18272         }
18273       break;
18274
18275     /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18276        There's also old PT___GETREGS40 == mach + 1 for old reg
18277        structure which lacks GBR.  */
18278     case EM_SH:
18279       switch (e_type)
18280         {
18281         case NT_NETBSDCORE_FIRSTMACH + 1:
18282           return _("PT___GETREGS40 (old reg structure)");
18283         case NT_NETBSDCORE_FIRSTMACH + 3:
18284           return _("PT_GETREGS (reg structure)");
18285         case NT_NETBSDCORE_FIRSTMACH + 5:
18286           return _("PT_GETFPREGS (fpreg structure)");
18287         default:
18288           break;
18289         }
18290       break;
18291
18292     /* On all other arch's, PT_GETREGS == mach+1 and
18293        PT_GETFPREGS == mach+3.  */
18294     default:
18295       switch (e_type)
18296         {
18297         case NT_NETBSDCORE_FIRSTMACH + 1:
18298           return _("PT_GETREGS (reg structure)");
18299         case NT_NETBSDCORE_FIRSTMACH + 3:
18300           return _("PT_GETFPREGS (fpreg structure)");
18301         default:
18302           break;
18303         }
18304     }
18305
18306   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
18307             e_type - NT_NETBSDCORE_FIRSTMACH);
18308   return buff;
18309 }
18310
18311 static const char *
18312 get_stapsdt_note_type (unsigned e_type)
18313 {
18314   static char buff[64];
18315
18316   switch (e_type)
18317     {
18318     case NT_STAPSDT:
18319       return _("NT_STAPSDT (SystemTap probe descriptors)");
18320
18321     default:
18322       break;
18323     }
18324
18325   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18326   return buff;
18327 }
18328
18329 static bfd_boolean
18330 print_stapsdt_note (Elf_Internal_Note *pnote)
18331 {
18332   size_t len, maxlen;
18333   unsigned long addr_size = is_32bit_elf ? 4 : 8;
18334   char *data = pnote->descdata;
18335   char *data_end = pnote->descdata + pnote->descsz;
18336   bfd_vma pc, base_addr, semaphore;
18337   char *provider, *probe, *arg_fmt;
18338
18339   if (pnote->descsz < (addr_size * 3))
18340     goto stapdt_note_too_small;
18341
18342   pc = byte_get ((unsigned char *) data, addr_size);
18343   data += addr_size;
18344
18345   base_addr = byte_get ((unsigned char *) data, addr_size);
18346   data += addr_size;
18347
18348   semaphore = byte_get ((unsigned char *) data, addr_size);
18349   data += addr_size;
18350
18351   if (data >= data_end)
18352     goto stapdt_note_too_small;
18353   maxlen = data_end - data;
18354   len = strnlen (data, maxlen);
18355   if (len < maxlen)
18356     {
18357       provider = data;
18358       data += len + 1;
18359     }
18360   else
18361     goto stapdt_note_too_small;
18362
18363   if (data >= data_end)
18364     goto stapdt_note_too_small;
18365   maxlen = data_end - data;
18366   len = strnlen (data, maxlen);
18367   if (len < maxlen)
18368     {
18369       probe = data;
18370       data += len + 1;
18371     }
18372   else
18373     goto stapdt_note_too_small;
18374
18375   if (data >= data_end)
18376     goto stapdt_note_too_small;
18377   maxlen = data_end - data;
18378   len = strnlen (data, maxlen);
18379   if (len < maxlen)
18380     {
18381       arg_fmt = data;
18382       data += len + 1;
18383     }
18384   else
18385     goto stapdt_note_too_small;
18386
18387   printf (_("    Provider: %s\n"), provider);
18388   printf (_("    Name: %s\n"), probe);
18389   printf (_("    Location: "));
18390   print_vma (pc, FULL_HEX);
18391   printf (_(", Base: "));
18392   print_vma (base_addr, FULL_HEX);
18393   printf (_(", Semaphore: "));
18394   print_vma (semaphore, FULL_HEX);
18395   printf ("\n");
18396   printf (_("    Arguments: %s\n"), arg_fmt);
18397
18398   return data == data_end;
18399
18400  stapdt_note_too_small:
18401   printf (_("  <corrupt - note is too small>\n"));
18402   error (_("corrupt stapdt note - the data size is too small\n"));
18403   return FALSE;
18404 }
18405
18406 static const char *
18407 get_ia64_vms_note_type (unsigned e_type)
18408 {
18409   static char buff[64];
18410
18411   switch (e_type)
18412     {
18413     case NT_VMS_MHD:
18414       return _("NT_VMS_MHD (module header)");
18415     case NT_VMS_LNM:
18416       return _("NT_VMS_LNM (language name)");
18417     case NT_VMS_SRC:
18418       return _("NT_VMS_SRC (source files)");
18419     case NT_VMS_TITLE:
18420       return "NT_VMS_TITLE";
18421     case NT_VMS_EIDC:
18422       return _("NT_VMS_EIDC (consistency check)");
18423     case NT_VMS_FPMODE:
18424       return _("NT_VMS_FPMODE (FP mode)");
18425     case NT_VMS_LINKTIME:
18426       return "NT_VMS_LINKTIME";
18427     case NT_VMS_IMGNAM:
18428       return _("NT_VMS_IMGNAM (image name)");
18429     case NT_VMS_IMGID:
18430       return _("NT_VMS_IMGID (image id)");
18431     case NT_VMS_LINKID:
18432       return _("NT_VMS_LINKID (link id)");
18433     case NT_VMS_IMGBID:
18434       return _("NT_VMS_IMGBID (build id)");
18435     case NT_VMS_GSTNAM:
18436       return _("NT_VMS_GSTNAM (sym table name)");
18437     case NT_VMS_ORIG_DYN:
18438       return "NT_VMS_ORIG_DYN";
18439     case NT_VMS_PATCHTIME:
18440       return "NT_VMS_PATCHTIME";
18441     default:
18442       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18443       return buff;
18444     }
18445 }
18446
18447 static bfd_boolean
18448 print_ia64_vms_note (Elf_Internal_Note * pnote)
18449 {
18450   int maxlen = pnote->descsz;
18451
18452   if (maxlen < 2 || (unsigned long) maxlen != pnote->descsz)
18453     goto desc_size_fail;
18454
18455   switch (pnote->type)
18456     {
18457     case NT_VMS_MHD:
18458       if (maxlen <= 36)
18459         goto desc_size_fail;
18460
18461       int l = (int) strnlen (pnote->descdata + 34, maxlen - 34);
18462
18463       printf (_("    Creation date  : %.17s\n"), pnote->descdata);
18464       printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
18465       if (l + 34 < maxlen)
18466         {
18467           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
18468           if (l + 35 < maxlen)
18469             printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
18470           else
18471             printf (_("    Module version : <missing>\n"));
18472         }
18473       else
18474         {
18475           printf (_("    Module name    : <missing>\n"));
18476           printf (_("    Module version : <missing>\n"));
18477         }
18478       break;
18479
18480     case NT_VMS_LNM:
18481       printf (_("   Language: %.*s\n"), maxlen, pnote->descdata);
18482       break;
18483
18484 #ifdef BFD64
18485     case NT_VMS_FPMODE:
18486       printf (_("   Floating Point mode: "));
18487       if (maxlen < 8)
18488         goto desc_size_fail;
18489       /* FIXME: Generate an error if descsz > 8 ?  */
18490
18491       printf ("0x%016" BFD_VMA_FMT "x\n",
18492               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
18493       break;
18494
18495     case NT_VMS_LINKTIME:
18496       printf (_("   Link time: "));
18497       if (maxlen < 8)
18498         goto desc_size_fail;
18499       /* FIXME: Generate an error if descsz > 8 ?  */
18500
18501       print_vms_time
18502         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
18503       printf ("\n");
18504       break;
18505
18506     case NT_VMS_PATCHTIME:
18507       printf (_("   Patch time: "));
18508       if (maxlen < 8)
18509         goto desc_size_fail;
18510       /* FIXME: Generate an error if descsz > 8 ?  */
18511
18512       print_vms_time
18513         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
18514       printf ("\n");
18515       break;
18516
18517     case NT_VMS_ORIG_DYN:
18518       if (maxlen < 34)
18519         goto desc_size_fail;
18520
18521       printf (_("   Major id: %u,  minor id: %u\n"),
18522               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
18523               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
18524       printf (_("   Last modified  : "));
18525       print_vms_time
18526         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
18527       printf (_("\n   Link flags  : "));
18528       printf ("0x%016" BFD_VMA_FMT "x\n",
18529               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
18530       printf (_("   Header flags: 0x%08x\n"),
18531               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
18532       printf (_("   Image id    : %.*s\n"), maxlen - 32, pnote->descdata + 32);
18533       break;
18534 #endif
18535
18536     case NT_VMS_IMGNAM:
18537       printf (_("    Image name: %.*s\n"), maxlen, pnote->descdata);
18538       break;
18539
18540     case NT_VMS_GSTNAM:
18541       printf (_("    Global symbol table name: %.*s\n"), maxlen, pnote->descdata);
18542       break;
18543
18544     case NT_VMS_IMGID:
18545       printf (_("    Image id: %.*s\n"), maxlen, pnote->descdata);
18546       break;
18547
18548     case NT_VMS_LINKID:
18549       printf (_("    Linker id: %.*s\n"), maxlen, pnote->descdata);
18550       break;
18551
18552     default:
18553       return FALSE;
18554     }
18555
18556   return TRUE;
18557
18558  desc_size_fail:
18559   printf (_("  <corrupt - data size is too small>\n"));
18560   error (_("corrupt IA64 note: data size is too small\n"));
18561   return FALSE;
18562 }
18563
18564 /* Find the symbol associated with a build attribute that is attached
18565    to address OFFSET.  If PNAME is non-NULL then store the name of
18566    the symbol (if found) in the provided pointer,  Returns NULL if a
18567    symbol could not be found.  */
18568
18569 static Elf_Internal_Sym *
18570 get_symbol_for_build_attribute (Filedata *       filedata,
18571                                 unsigned long    offset,
18572                                 bfd_boolean      is_open_attr,
18573                                 const char **    pname)
18574 {
18575   static Filedata *         saved_filedata = NULL;
18576   static char *             strtab;
18577   static unsigned long      strtablen;
18578   static Elf_Internal_Sym * symtab;
18579   static unsigned long      nsyms;
18580   Elf_Internal_Sym *        saved_sym = NULL;
18581   Elf_Internal_Sym *        sym;
18582
18583   if (filedata->section_headers != NULL
18584       && (saved_filedata == NULL || filedata != saved_filedata))
18585     {
18586       Elf_Internal_Shdr * symsec;
18587
18588       /* Load the symbol and string sections.  */
18589       for (symsec = filedata->section_headers;
18590            symsec < filedata->section_headers + filedata->file_header.e_shnum;
18591            symsec ++)
18592         {
18593           if (symsec->sh_type == SHT_SYMTAB)
18594             {
18595               symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
18596
18597               if (symsec->sh_link < filedata->file_header.e_shnum)
18598                 {
18599                   Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
18600
18601                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
18602                                               1, strtab_sec->sh_size,
18603                                               _("string table"));
18604                   strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
18605                 }
18606             }
18607         }
18608       saved_filedata = filedata;
18609     }
18610
18611   if (symtab == NULL || strtab == NULL)
18612     return NULL;
18613
18614   /* Find a symbol whose value matches offset.  */
18615   for (sym = symtab; sym < symtab + nsyms; sym ++)
18616     if (sym->st_value == offset)
18617       {
18618         if (sym->st_name >= strtablen)
18619           /* Huh ?  This should not happen.  */
18620           continue;
18621
18622         if (strtab[sym->st_name] == 0)
18623           continue;
18624
18625         /* The AArch64 and ARM architectures define mapping symbols
18626            (eg $d, $x, $t) which we want to ignore.  */
18627         if (strtab[sym->st_name] == '$'
18628             && strtab[sym->st_name + 1] != 0
18629             && strtab[sym->st_name + 2] == 0)
18630           continue;
18631
18632         if (is_open_attr)
18633           {
18634             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18635                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
18636                FUNC symbols entirely.  */
18637             switch (ELF_ST_TYPE (sym->st_info))
18638               {
18639               case STT_OBJECT:
18640               case STT_FILE:
18641                 saved_sym = sym;
18642                 if (sym->st_size)
18643                   {
18644                     /* If the symbol has a size associated
18645                        with it then we can stop searching.  */
18646                     sym = symtab + nsyms;
18647                   }
18648                 continue;
18649
18650               case STT_FUNC:
18651                 /* Ignore function symbols.  */
18652                 continue;
18653
18654               default:
18655                 break;
18656               }
18657
18658             switch (ELF_ST_BIND (sym->st_info))
18659               {
18660               case STB_GLOBAL:
18661                 if (saved_sym == NULL
18662                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
18663                   saved_sym = sym;
18664                 break;
18665
18666               case STB_LOCAL:
18667                 if (saved_sym == NULL)
18668                   saved_sym = sym;
18669                 break;
18670
18671               default:
18672                 break;
18673               }
18674           }
18675         else
18676           {
18677             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
18678               continue;
18679
18680             saved_sym = sym;
18681             break;
18682           }
18683       }
18684
18685   if (saved_sym && pname)
18686     * pname = strtab + saved_sym->st_name;
18687
18688   return saved_sym;
18689 }
18690
18691 /* Returns true iff addr1 and addr2 are in the same section.  */
18692
18693 static bfd_boolean
18694 same_section (Filedata * filedata, unsigned long addr1, unsigned long addr2)
18695 {
18696   Elf_Internal_Shdr * a1;
18697   Elf_Internal_Shdr * a2;
18698
18699   a1 = find_section_by_address (filedata, addr1);
18700   a2 = find_section_by_address (filedata, addr2);
18701
18702   return a1 == a2 && a1 != NULL;
18703 }
18704
18705 static bfd_boolean
18706 print_gnu_build_attribute_description (Elf_Internal_Note *  pnote,
18707                                        Filedata *           filedata)
18708 {
18709   static unsigned long  global_offset = 0;
18710   static unsigned long  global_end = 0;
18711   static unsigned long  func_offset = 0;
18712   static unsigned long  func_end = 0;
18713
18714   Elf_Internal_Sym *    sym;
18715   const char *          name;
18716   unsigned long         start;
18717   unsigned long         end;
18718   bfd_boolean           is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
18719
18720   switch (pnote->descsz)
18721     {
18722     case 0:
18723       /* A zero-length description means that the range of
18724          the previous note of the same type should be used.  */
18725       if (is_open_attr)
18726         {
18727           if (global_end > global_offset)
18728             printf (_("    Applies to region from %#lx to %#lx\n"),
18729                     global_offset, global_end);
18730           else
18731             printf (_("    Applies to region from %#lx\n"), global_offset);
18732         }
18733       else
18734         {
18735           if (func_end > func_offset)
18736             printf (_("    Applies to region from %#lx to %#lx\n"), func_offset, func_end);
18737           else
18738             printf (_("    Applies to region from %#lx\n"), func_offset);
18739         }
18740       return TRUE;
18741
18742     case 4:
18743       start = byte_get ((unsigned char *) pnote->descdata, 4);
18744       end = 0;
18745       break;
18746
18747     case 8:
18748       if (is_32bit_elf)
18749         {
18750           /* FIXME: We should check that version 3+ notes are being used here...  */
18751           start = byte_get ((unsigned char *) pnote->descdata, 4);
18752           end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18753         }
18754       else
18755         {
18756           start = byte_get ((unsigned char *) pnote->descdata, 8);
18757           end = 0;
18758         }
18759       break;
18760
18761     case 16:
18762       start = byte_get ((unsigned char *) pnote->descdata, 8);
18763       end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
18764       break;
18765
18766     default:
18767       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
18768       printf (_("    <invalid descsz>"));
18769       return FALSE;
18770     }
18771
18772   name = NULL;
18773   sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
18774   /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18775      in order to avoid them being confused with the start address of the
18776      first function in the file...  */
18777   if (sym == NULL && is_open_attr)
18778     sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
18779                                           & name);
18780
18781   if (end == 0 && sym != NULL && sym->st_size > 0)
18782     end = start + sym->st_size;
18783
18784   if (is_open_attr)
18785     {
18786       /* FIXME: Need to properly allow for section alignment.
18787          16 is just the alignment used on x86_64.  */
18788       if (global_end > 0
18789           && start > BFD_ALIGN (global_end, 16)
18790           /* Build notes are not guaranteed to be organised in order of
18791              increasing address, but we should find the all of the notes
18792              for one section in the same place.  */
18793           && same_section (filedata, start, global_end))
18794         warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18795               global_end + 1, start - 1);
18796
18797       printf (_("    Applies to region from %#lx"), start);
18798       global_offset = start;
18799
18800       if (end)
18801         {
18802           printf (_(" to %#lx"), end);
18803           global_end = end;
18804         }
18805     }
18806   else
18807     {
18808       printf (_("    Applies to region from %#lx"), start);
18809       func_offset = start;
18810
18811       if (end)
18812         {
18813           printf (_(" to %#lx"), end);
18814           func_end = end;
18815         }
18816     }
18817
18818   if (sym && name)
18819     printf (_(" (%s)"), name);
18820
18821   printf ("\n");
18822   return TRUE;
18823 }
18824
18825 static bfd_boolean
18826 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
18827 {
18828   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
18829   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
18830   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
18831   char         name_type;
18832   char         name_attribute;
18833   const char * expected_types;
18834   const char * name = pnote->namedata;
18835   const char * text;
18836   signed int   left;
18837
18838   if (name == NULL || pnote->namesz < 2)
18839     {
18840       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18841       print_symbol (-20, _("  <corrupt name>"));
18842       return FALSE;
18843     }
18844
18845   if (do_wide)
18846     left = 28;
18847   else
18848     left = 20;
18849
18850   /* Version 2 of the spec adds a "GA" prefix to the name field.  */
18851   if (name[0] == 'G' && name[1] == 'A')
18852     {
18853       if (pnote->namesz < 4)
18854         {
18855           error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18856           print_symbol (-20, _("  <corrupt name>"));
18857           return FALSE;
18858         }
18859
18860       printf ("GA");
18861       name += 2;
18862       left -= 2;
18863     }
18864
18865   switch ((name_type = * name))
18866     {
18867     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18868     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18869     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18870     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18871       printf ("%c", * name);
18872       left --;
18873       break;
18874     default:
18875       error (_("unrecognised attribute type in name field: %d\n"), name_type);
18876       print_symbol (-20, _("<unknown name type>"));
18877       return FALSE;
18878     }
18879
18880   ++ name;
18881   text = NULL;
18882
18883   switch ((name_attribute = * name))
18884     {
18885     case GNU_BUILD_ATTRIBUTE_VERSION:
18886       text = _("<version>");
18887       expected_types = string_expected;
18888       ++ name;
18889       break;
18890     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18891       text = _("<stack prot>");
18892       expected_types = "!+*";
18893       ++ name;
18894       break;
18895     case GNU_BUILD_ATTRIBUTE_RELRO:
18896       text = _("<relro>");
18897       expected_types = bool_expected;
18898       ++ name;
18899       break;
18900     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
18901       text = _("<stack size>");
18902       expected_types = number_expected;
18903       ++ name;
18904       break;
18905     case GNU_BUILD_ATTRIBUTE_TOOL:
18906       text = _("<tool>");
18907       expected_types = string_expected;
18908       ++ name;
18909       break;
18910     case GNU_BUILD_ATTRIBUTE_ABI:
18911       text = _("<ABI>");
18912       expected_types = "$*";
18913       ++ name;
18914       break;
18915     case GNU_BUILD_ATTRIBUTE_PIC:
18916       text = _("<PIC>");
18917       expected_types = number_expected;
18918       ++ name;
18919       break;
18920     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
18921       text = _("<short enum>");
18922       expected_types = bool_expected;
18923       ++ name;
18924       break;
18925     default:
18926       if (ISPRINT (* name))
18927         {
18928           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
18929
18930           if (len > left && ! do_wide)
18931             len = left;
18932           printf ("%.*s:", len, name);
18933           left -= len;
18934           name += len;
18935         }
18936       else
18937         {
18938           static char tmpbuf [128];
18939
18940           error (_("unrecognised byte in name field: %d\n"), * name);
18941           sprintf (tmpbuf, _("<unknown:_%d>"), * name);
18942           text = tmpbuf;
18943           name ++;
18944         }
18945       expected_types = "*$!+";
18946       break;
18947     }
18948
18949   if (text)
18950     left -= printf ("%s", text);
18951
18952   if (strchr (expected_types, name_type) == NULL)
18953     warn (_("attribute does not have an expected type (%c)\n"), name_type);
18954
18955   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
18956     {
18957       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
18958              (unsigned long) pnote->namesz,
18959              (long) (name - pnote->namedata));
18960       return FALSE;
18961     }
18962
18963   if (left < 1 && ! do_wide)
18964     return TRUE;
18965
18966   switch (name_type)
18967     {
18968     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18969       {
18970         unsigned int        bytes;
18971         unsigned long long  val = 0;
18972         unsigned int        shift = 0;
18973         char *              decoded = NULL;
18974
18975         bytes = pnote->namesz - (name - pnote->namedata);
18976         if (bytes > 0)
18977           /* The -1 is because the name field is always 0 terminated, and we
18978              want to be able to ensure that the shift in the while loop below
18979              will not overflow.  */
18980           -- bytes;
18981
18982         if (bytes > sizeof (val))
18983           {
18984             error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
18985                    bytes);
18986             bytes = sizeof (val);
18987           }
18988         /* We do not bother to warn if bytes == 0 as this can
18989            happen with some early versions of the gcc plugin.  */
18990
18991         while (bytes --)
18992           {
18993             unsigned long byte = (* name ++) & 0xff;
18994
18995             val |= byte << shift;
18996             shift += 8;
18997           }
18998
18999         switch (name_attribute)
19000           {
19001           case GNU_BUILD_ATTRIBUTE_PIC:
19002             switch (val)
19003               {
19004               case 0: decoded = "static"; break;
19005               case 1: decoded = "pic"; break;
19006               case 2: decoded = "PIC"; break;
19007               case 3: decoded = "pie"; break;
19008               case 4: decoded = "PIE"; break;
19009               default: break;
19010               }
19011             break;
19012           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
19013             switch (val)
19014               {
19015                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
19016               case 0: decoded = "off"; break;
19017               case 1: decoded = "on"; break;
19018               case 2: decoded = "all"; break;
19019               case 3: decoded = "strong"; break;
19020               case 4: decoded = "explicit"; break;
19021               default: break;
19022               }
19023             break;
19024           default:
19025             break;
19026           }
19027
19028         if (decoded != NULL)
19029           {
19030             print_symbol (-left, decoded);
19031             left = 0;
19032           }
19033         else if (val == 0)
19034           {
19035             printf ("0x0");
19036             left -= 3;
19037           }
19038         else
19039           {
19040             if (do_wide)
19041               left -= printf ("0x%llx", val);
19042             else
19043               left -= printf ("0x%-.*llx", left, val);
19044           }
19045       }
19046       break;
19047     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
19048       left -= print_symbol (- left, name);
19049       break;
19050     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
19051       left -= print_symbol (- left, "true");
19052       break;
19053     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
19054       left -= print_symbol (- left, "false");
19055       break;
19056     }
19057
19058   if (do_wide && left > 0)
19059     printf ("%-*s", left, " ");
19060
19061   return TRUE;
19062 }
19063
19064 /* Note that by the ELF standard, the name field is already null byte
19065    terminated, and namesz includes the terminating null byte.
19066    I.E. the value of namesz for the name "FSF" is 4.
19067
19068    If the value of namesz is zero, there is no name present.  */
19069
19070 static bfd_boolean
19071 process_note (Elf_Internal_Note *  pnote,
19072               Filedata *           filedata)
19073 {
19074   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
19075   const char * nt;
19076
19077   if (pnote->namesz == 0)
19078     /* If there is no note name, then use the default set of
19079        note type strings.  */
19080     nt = get_note_type (filedata, pnote->type);
19081
19082   else if (const_strneq (pnote->namedata, "GNU"))
19083     /* GNU-specific object file notes.  */
19084     nt = get_gnu_elf_note_type (pnote->type);
19085
19086   else if (const_strneq (pnote->namedata, "FreeBSD"))
19087     /* FreeBSD-specific core file notes.  */
19088     nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
19089
19090   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
19091     /* NetBSD-specific core file notes.  */
19092     nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
19093
19094   else if (const_strneq (pnote->namedata, "NetBSD"))
19095     /* NetBSD-specific core file notes.  */
19096     return process_netbsd_elf_note (pnote);
19097
19098   else if (const_strneq (pnote->namedata, "PaX"))
19099     /* NetBSD-specific core file notes.  */
19100     return process_netbsd_elf_note (pnote);
19101
19102   else if (strneq (pnote->namedata, "SPU/", 4))
19103     {
19104       /* SPU-specific core file notes.  */
19105       nt = pnote->namedata + 4;
19106       name = "SPU";
19107     }
19108
19109   else if (const_strneq (pnote->namedata, "IPF/VMS"))
19110     /* VMS/ia64-specific file notes.  */
19111     nt = get_ia64_vms_note_type (pnote->type);
19112
19113   else if (const_strneq (pnote->namedata, "stapsdt"))
19114     nt = get_stapsdt_note_type (pnote->type);
19115
19116   else
19117     /* Don't recognize this note name; just use the default set of
19118        note type strings.  */
19119     nt = get_note_type (filedata, pnote->type);
19120
19121   printf ("  ");
19122
19123   if (((const_strneq (pnote->namedata, "GA")
19124         && strchr ("*$!+", pnote->namedata[2]) != NULL)
19125        || strchr ("*$!+", pnote->namedata[0]) != NULL)
19126       && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
19127           || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
19128     print_gnu_build_attribute_name (pnote);
19129   else
19130     print_symbol (-20, name);
19131
19132   if (do_wide)
19133     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
19134   else
19135     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
19136
19137   if (const_strneq (pnote->namedata, "IPF/VMS"))
19138     return print_ia64_vms_note (pnote);
19139   else if (const_strneq (pnote->namedata, "GNU"))
19140     return print_gnu_note (filedata, pnote);
19141   else if (const_strneq (pnote->namedata, "stapsdt"))
19142     return print_stapsdt_note (pnote);
19143   else if (const_strneq (pnote->namedata, "CORE"))
19144     return print_core_note (pnote);
19145   else if (((const_strneq (pnote->namedata, "GA")
19146              && strchr ("*$!+", pnote->namedata[2]) != NULL)
19147             || strchr ("*$!+", pnote->namedata[0]) != NULL)
19148            && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
19149                || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
19150     return print_gnu_build_attribute_description (pnote, filedata);
19151
19152   if (pnote->descsz)
19153     {
19154       unsigned long i;
19155
19156       printf (_("   description data: "));
19157       for (i = 0; i < pnote->descsz; i++)
19158         printf ("%02x ", pnote->descdata[i] & 0xff);
19159       if (!do_wide)
19160         printf ("\n");
19161     }
19162
19163   if (do_wide)
19164     printf ("\n");
19165
19166   return TRUE;
19167 }
19168
19169 static bfd_boolean
19170 process_notes_at (Filedata *           filedata,
19171                   Elf_Internal_Shdr *  section,
19172                   bfd_vma              offset,
19173                   bfd_vma              length,
19174                   bfd_vma              align)
19175 {
19176   Elf_External_Note * pnotes;
19177   Elf_External_Note * external;
19178   char *              end;
19179   bfd_boolean         res = TRUE;
19180
19181   if (length <= 0)
19182     return FALSE;
19183
19184   if (section)
19185     {
19186       pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
19187       if (pnotes)
19188         {
19189           if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
19190             return FALSE;
19191         }
19192     }
19193   else
19194     pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
19195                                              _("notes"));
19196
19197   if (pnotes == NULL)
19198     return FALSE;
19199
19200   external = pnotes;
19201
19202   if (section)
19203     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
19204   else
19205     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19206             (unsigned long) offset, (unsigned long) length);
19207
19208   /* NB: Some note sections may have alignment value of 0 or 1.  gABI
19209      specifies that notes should be aligned to 4 bytes in 32-bit
19210      objects and to 8 bytes in 64-bit objects.  As a Linux extension,
19211      we also support 4 byte alignment in 64-bit objects.  If section
19212      alignment is less than 4, we treate alignment as 4 bytes.   */
19213   if (align < 4)
19214     align = 4;
19215   else if (align != 4 && align != 8)
19216     {
19217       warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19218             (long) align);
19219       return FALSE;
19220     }
19221
19222   printf (_("  %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19223
19224   end = (char *) pnotes + length;
19225   while ((char *) external < end)
19226     {
19227       Elf_Internal_Note inote;
19228       size_t min_notesz;
19229       char * next;
19230       char * temp = NULL;
19231       size_t data_remaining = end - (char *) external;
19232
19233       if (!is_ia64_vms (filedata))
19234         {
19235           /* PR binutils/15191
19236              Make sure that there is enough data to read.  */
19237           min_notesz = offsetof (Elf_External_Note, name);
19238           if (data_remaining < min_notesz)
19239             {
19240               warn (ngettext ("Corrupt note: only %ld byte remains, "
19241                               "not enough for a full note\n",
19242                               "Corrupt note: only %ld bytes remain, "
19243                               "not enough for a full note\n",
19244                               data_remaining),
19245                     (long) data_remaining);
19246               break;
19247             }
19248           data_remaining -= min_notesz;
19249
19250           inote.type     = BYTE_GET (external->type);
19251           inote.namesz   = BYTE_GET (external->namesz);
19252           inote.namedata = external->name;
19253           inote.descsz   = BYTE_GET (external->descsz);
19254           inote.descdata = ((char *) external
19255                             + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
19256           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
19257           next = ((char *) external
19258                   + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
19259         }
19260       else
19261         {
19262           Elf64_External_VMS_Note *vms_external;
19263
19264           /* PR binutils/15191
19265              Make sure that there is enough data to read.  */
19266           min_notesz = offsetof (Elf64_External_VMS_Note, name);
19267           if (data_remaining < min_notesz)
19268             {
19269               warn (ngettext ("Corrupt note: only %ld byte remains, "
19270                               "not enough for a full note\n",
19271                               "Corrupt note: only %ld bytes remain, "
19272                               "not enough for a full note\n",
19273                               data_remaining),
19274                     (long) data_remaining);
19275               break;
19276             }
19277           data_remaining -= min_notesz;
19278
19279           vms_external = (Elf64_External_VMS_Note *) external;
19280           inote.type     = BYTE_GET (vms_external->type);
19281           inote.namesz   = BYTE_GET (vms_external->namesz);
19282           inote.namedata = vms_external->name;
19283           inote.descsz   = BYTE_GET (vms_external->descsz);
19284           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
19285           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
19286           next = inote.descdata + align_power (inote.descsz, 3);
19287         }
19288
19289       /* PR 17531: file: 3443835e.  */
19290       /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
19291       if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
19292           || (size_t) (inote.descdata - inote.namedata) > data_remaining
19293           || (size_t) (next - inote.descdata) < inote.descsz
19294           || ((size_t) (next - inote.descdata)
19295               > data_remaining - (size_t) (inote.descdata - inote.namedata)))
19296         {
19297           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19298                 (unsigned long) ((char *) external - (char *) pnotes));
19299           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19300                 inote.type, inote.namesz, inote.descsz, (int) align);
19301           break;
19302         }
19303
19304       external = (Elf_External_Note *) next;
19305
19306       /* Verify that name is null terminated.  It appears that at least
19307          one version of Linux (RedHat 6.0) generates corefiles that don't
19308          comply with the ELF spec by failing to include the null byte in
19309          namesz.  */
19310       if (inote.namesz > 0 && inote.namedata[inote.namesz - 1] != '\0')
19311         {
19312           if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
19313             {
19314               temp = (char *) malloc (inote.namesz + 1);
19315               if (temp == NULL)
19316                 {
19317                   error (_("Out of memory allocating space for inote name\n"));
19318                   res = FALSE;
19319                   break;
19320                 }
19321
19322               memcpy (temp, inote.namedata, inote.namesz);
19323               inote.namedata = temp;
19324             }
19325           inote.namedata[inote.namesz] = 0;
19326         }
19327
19328       if (! process_note (& inote, filedata))
19329         res = FALSE;
19330
19331       if (temp != NULL)
19332         {
19333           free (temp);
19334           temp = NULL;
19335         }
19336     }
19337
19338   free (pnotes);
19339
19340   return res;
19341 }
19342
19343 static bfd_boolean
19344 process_corefile_note_segments (Filedata * filedata)
19345 {
19346   Elf_Internal_Phdr * segment;
19347   unsigned int i;
19348   bfd_boolean res = TRUE;
19349
19350   if (! get_program_headers (filedata))
19351     return TRUE;
19352
19353   for (i = 0, segment = filedata->program_headers;
19354        i < filedata->file_header.e_phnum;
19355        i++, segment++)
19356     {
19357       if (segment->p_type == PT_NOTE)
19358         if (! process_notes_at (filedata, NULL,
19359                                 (bfd_vma) segment->p_offset,
19360                                 (bfd_vma) segment->p_filesz,
19361                                 (bfd_vma) segment->p_align))
19362           res = FALSE;
19363     }
19364
19365   return res;
19366 }
19367
19368 static bfd_boolean
19369 process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
19370 {
19371   Elf_External_Note * pnotes;
19372   Elf_External_Note * external;
19373   char * end;
19374   bfd_boolean res = TRUE;
19375
19376   if (length <= 0)
19377     return FALSE;
19378
19379   pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
19380                                            _("v850 notes"));
19381   if (pnotes == NULL)
19382     return FALSE;
19383
19384   external = pnotes;
19385   end = (char*) pnotes + length;
19386
19387   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19388           (unsigned long) offset, (unsigned long) length);
19389
19390   while ((char *) external + sizeof (Elf_External_Note) < end)
19391     {
19392       Elf_External_Note * next;
19393       Elf_Internal_Note inote;
19394
19395       inote.type     = BYTE_GET (external->type);
19396       inote.namesz   = BYTE_GET (external->namesz);
19397       inote.namedata = external->name;
19398       inote.descsz   = BYTE_GET (external->descsz);
19399       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
19400       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
19401
19402       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
19403         {
19404           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
19405           inote.descdata = inote.namedata;
19406           inote.namesz   = 0;
19407         }
19408
19409       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
19410
19411       if (   ((char *) next > end)
19412           || ((char *) next <  (char *) pnotes))
19413         {
19414           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19415                 (unsigned long) ((char *) external - (char *) pnotes));
19416           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19417                 inote.type, inote.namesz, inote.descsz);
19418           break;
19419         }
19420
19421       external = next;
19422
19423       /* Prevent out-of-bounds indexing.  */
19424       if (   inote.namedata + inote.namesz > end
19425           || inote.namedata + inote.namesz < inote.namedata)
19426         {
19427           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19428                 (unsigned long) ((char *) external - (char *) pnotes));
19429           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19430                 inote.type, inote.namesz, inote.descsz);
19431           break;
19432         }
19433
19434       printf ("  %s: ", get_v850_elf_note_type (inote.type));
19435
19436       if (! print_v850_note (& inote))
19437         {
19438           res = FALSE;
19439           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19440                   inote.namesz, inote.descsz);
19441         }
19442     }
19443
19444   free (pnotes);
19445
19446   return res;
19447 }
19448
19449 static bfd_boolean
19450 process_note_sections (Filedata * filedata)
19451 {
19452   Elf_Internal_Shdr * section;
19453   unsigned long i;
19454   unsigned int n = 0;
19455   bfd_boolean res = TRUE;
19456
19457   for (i = 0, section = filedata->section_headers;
19458        i < filedata->file_header.e_shnum && section != NULL;
19459        i++, section++)
19460     {
19461       if (section->sh_type == SHT_NOTE)
19462         {
19463           if (! process_notes_at (filedata, section,
19464                                   (bfd_vma) section->sh_offset,
19465                                   (bfd_vma) section->sh_size,
19466                                   (bfd_vma) section->sh_addralign))
19467             res = FALSE;
19468           n++;
19469         }
19470
19471       if ((   filedata->file_header.e_machine == EM_V800
19472            || filedata->file_header.e_machine == EM_V850
19473            || filedata->file_header.e_machine == EM_CYGNUS_V850)
19474           && section->sh_type == SHT_RENESAS_INFO)
19475         {
19476           if (! process_v850_notes (filedata,
19477                                     (bfd_vma) section->sh_offset,
19478                                     (bfd_vma) section->sh_size))
19479             res = FALSE;
19480           n++;
19481         }
19482     }
19483
19484   if (n == 0)
19485     /* Try processing NOTE segments instead.  */
19486     return process_corefile_note_segments (filedata);
19487
19488   return res;
19489 }
19490
19491 static bfd_boolean
19492 process_notes (Filedata * filedata)
19493 {
19494   /* If we have not been asked to display the notes then do nothing.  */
19495   if (! do_notes)
19496     return TRUE;
19497
19498   if (filedata->file_header.e_type != ET_CORE)
19499     return process_note_sections (filedata);
19500
19501   /* No program headers means no NOTE segment.  */
19502   if (filedata->file_header.e_phnum > 0)
19503     return process_corefile_note_segments (filedata);
19504
19505   printf (_("No note segments present in the core file.\n"));
19506   return TRUE;
19507 }
19508
19509 static unsigned char *
19510 display_public_gnu_attributes (unsigned char * start,
19511                                const unsigned char * const end)
19512 {
19513   printf (_("  Unknown GNU attribute: %s\n"), start);
19514
19515   start += strnlen ((char *) start, end - start);
19516   display_raw_attribute (start, end);
19517
19518   return (unsigned char *) end;
19519 }
19520
19521 static unsigned char *
19522 display_generic_attribute (unsigned char * start,
19523                            unsigned int tag,
19524                            const unsigned char * const end)
19525 {
19526   if (tag == 0)
19527     return (unsigned char *) end;
19528
19529   return display_tag_value (tag, start, end);
19530 }
19531
19532 static bfd_boolean
19533 process_arch_specific (Filedata * filedata)
19534 {
19535   if (! do_arch)
19536     return TRUE;
19537
19538   switch (filedata->file_header.e_machine)
19539     {
19540     case EM_ARC:
19541     case EM_ARC_COMPACT:
19542     case EM_ARC_COMPACT2:
19543       return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
19544                                  display_arc_attribute,
19545                                  display_generic_attribute);
19546     case EM_ARM:
19547       return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
19548                                  display_arm_attribute,
19549                                  display_generic_attribute);
19550
19551     case EM_MIPS:
19552     case EM_MIPS_RS3_LE:
19553       return process_mips_specific (filedata);
19554
19555     case EM_MSP430:
19556      return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
19557                                 display_msp430x_attribute,
19558                                 display_generic_attribute);
19559
19560     case EM_RISCV:
19561      return process_attributes (filedata, "riscv", SHT_RISCV_ATTRIBUTES,
19562                                 display_riscv_attribute,
19563                                 display_generic_attribute);
19564
19565     case EM_NDS32:
19566       return process_nds32_specific (filedata);
19567
19568     case EM_PPC:
19569     case EM_PPC64:
19570       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19571                                  display_power_gnu_attribute);
19572
19573     case EM_S390:
19574     case EM_S390_OLD:
19575       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19576                                  display_s390_gnu_attribute);
19577
19578     case EM_SPARC:
19579     case EM_SPARC32PLUS:
19580     case EM_SPARCV9:
19581       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19582                                  display_sparc_gnu_attribute);
19583
19584     case EM_TI_C6000:
19585       return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
19586                                  display_tic6x_attribute,
19587                                  display_generic_attribute);
19588
19589     default:
19590       return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
19591                                  display_public_gnu_attributes,
19592                                  display_generic_attribute);
19593     }
19594 }
19595
19596 static bfd_boolean
19597 get_file_header (Filedata * filedata)
19598 {
19599   /* Read in the identity array.  */
19600   if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
19601     return FALSE;
19602
19603   /* Determine how to read the rest of the header.  */
19604   switch (filedata->file_header.e_ident[EI_DATA])
19605     {
19606     default:
19607     case ELFDATANONE:
19608     case ELFDATA2LSB:
19609       byte_get = byte_get_little_endian;
19610       byte_put = byte_put_little_endian;
19611       break;
19612     case ELFDATA2MSB:
19613       byte_get = byte_get_big_endian;
19614       byte_put = byte_put_big_endian;
19615       break;
19616     }
19617
19618   /* For now we only support 32 bit and 64 bit ELF files.  */
19619   is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
19620
19621   /* Read in the rest of the header.  */
19622   if (is_32bit_elf)
19623     {
19624       Elf32_External_Ehdr ehdr32;
19625
19626       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
19627         return FALSE;
19628
19629       filedata->file_header.e_type      = BYTE_GET (ehdr32.e_type);
19630       filedata->file_header.e_machine   = BYTE_GET (ehdr32.e_machine);
19631       filedata->file_header.e_version   = BYTE_GET (ehdr32.e_version);
19632       filedata->file_header.e_entry     = BYTE_GET (ehdr32.e_entry);
19633       filedata->file_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
19634       filedata->file_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
19635       filedata->file_header.e_flags     = BYTE_GET (ehdr32.e_flags);
19636       filedata->file_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
19637       filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
19638       filedata->file_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
19639       filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
19640       filedata->file_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
19641       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
19642     }
19643   else
19644     {
19645       Elf64_External_Ehdr ehdr64;
19646
19647       /* If we have been compiled with sizeof (bfd_vma) == 4, then
19648          we will not be able to cope with the 64bit data found in
19649          64 ELF files.  Detect this now and abort before we start
19650          overwriting things.  */
19651       if (sizeof (bfd_vma) < 8)
19652         {
19653           error (_("This instance of readelf has been built without support for a\n\
19654 64 bit data type and so it cannot read 64 bit ELF files.\n"));
19655           return FALSE;
19656         }
19657
19658       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
19659         return FALSE;
19660
19661       filedata->file_header.e_type      = BYTE_GET (ehdr64.e_type);
19662       filedata->file_header.e_machine   = BYTE_GET (ehdr64.e_machine);
19663       filedata->file_header.e_version   = BYTE_GET (ehdr64.e_version);
19664       filedata->file_header.e_entry     = BYTE_GET (ehdr64.e_entry);
19665       filedata->file_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
19666       filedata->file_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
19667       filedata->file_header.e_flags     = BYTE_GET (ehdr64.e_flags);
19668       filedata->file_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
19669       filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
19670       filedata->file_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
19671       filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
19672       filedata->file_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
19673       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
19674     }
19675
19676   if (filedata->file_header.e_shoff)
19677     {
19678       /* There may be some extensions in the first section header.  Don't
19679          bomb if we can't read it.  */
19680       if (is_32bit_elf)
19681         get_32bit_section_headers (filedata, TRUE);
19682       else
19683         get_64bit_section_headers (filedata, TRUE);
19684     }
19685
19686   return TRUE;
19687 }
19688
19689 static void
19690 close_file (Filedata * filedata)
19691 {
19692   if (filedata)
19693     {
19694       if (filedata->handle)
19695         fclose (filedata->handle);
19696       free (filedata);
19697     }
19698 }
19699
19700 void
19701 close_debug_file (void * data)
19702 {
19703   close_file ((Filedata *) data);
19704 }
19705
19706 static Filedata *
19707 open_file (const char * pathname)
19708 {
19709   struct stat  statbuf;
19710   Filedata *   filedata = NULL;
19711
19712   if (stat (pathname, & statbuf) < 0
19713       || ! S_ISREG (statbuf.st_mode))
19714     goto fail;
19715
19716   filedata = calloc (1, sizeof * filedata);
19717   if (filedata == NULL)
19718     goto fail;
19719
19720   filedata->handle = fopen (pathname, "rb");
19721   if (filedata->handle == NULL)
19722     goto fail;
19723
19724   filedata->file_size = (bfd_size_type) statbuf.st_size;
19725   filedata->file_name = pathname;
19726
19727   if (! get_file_header (filedata))
19728     goto fail;
19729
19730   if (filedata->file_header.e_shoff)
19731     {
19732       bfd_boolean res;
19733
19734       /* Read the section headers again, this time for real.  */
19735       if (is_32bit_elf)
19736         res = get_32bit_section_headers (filedata, FALSE);
19737       else
19738         res = get_64bit_section_headers (filedata, FALSE);
19739
19740       if (!res)
19741         goto fail;
19742     }
19743
19744   return filedata;
19745
19746  fail:
19747   if (filedata)
19748     {
19749       if (filedata->handle)
19750         fclose (filedata->handle);
19751       free (filedata);
19752     }
19753   return NULL;
19754 }
19755
19756 void *
19757 open_debug_file (const char * pathname)
19758 {
19759   return open_file (pathname);
19760 }
19761
19762 /* Process one ELF object file according to the command line options.
19763    This file may actually be stored in an archive.  The file is
19764    positioned at the start of the ELF object.  Returns TRUE if no
19765    problems were encountered, FALSE otherwise.  */
19766
19767 static bfd_boolean
19768 process_object (Filedata * filedata)
19769 {
19770   bfd_boolean  have_separate_files;
19771   unsigned int i;
19772   bfd_boolean res = TRUE;
19773
19774   if (! get_file_header (filedata))
19775     {
19776       error (_("%s: Failed to read file header\n"), filedata->file_name);
19777       return FALSE;
19778     }
19779
19780   /* Initialise per file variables.  */
19781   for (i = ARRAY_SIZE (version_info); i--;)
19782     version_info[i] = 0;
19783
19784   for (i = ARRAY_SIZE (dynamic_info); i--;)
19785     dynamic_info[i] = 0;
19786   dynamic_info_DT_GNU_HASH = 0;
19787   dynamic_info_DT_MIPS_XHASH = 0;
19788
19789   /* Process the file.  */
19790   if (show_name)
19791     printf (_("\nFile: %s\n"), filedata->file_name);
19792
19793   /* Initialise the dump_sects array from the cmdline_dump_sects array.
19794      Note we do this even if cmdline_dump_sects is empty because we
19795      must make sure that the dump_sets array is zeroed out before each
19796      object file is processed.  */
19797   if (filedata->num_dump_sects > cmdline.num_dump_sects)
19798     memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
19799
19800   if (cmdline.num_dump_sects > 0)
19801     {
19802       if (filedata->num_dump_sects == 0)
19803         /* A sneaky way of allocating the dump_sects array.  */
19804         request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
19805
19806       assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
19807       memcpy (filedata->dump_sects, cmdline.dump_sects,
19808               cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
19809     }
19810
19811   if (! process_file_header (filedata))
19812     return FALSE;
19813
19814   if (! process_section_headers (filedata))
19815     {
19816       /* Without loaded section headers we cannot process lots of things.  */
19817       do_unwind = do_version = do_dump = do_arch = FALSE;
19818
19819       if (! do_using_dynamic)
19820         do_syms = do_dyn_syms = do_reloc = FALSE;
19821     }
19822
19823   if (! process_section_groups (filedata))
19824     /* Without loaded section groups we cannot process unwind.  */
19825     do_unwind = FALSE;
19826
19827   if (process_program_headers (filedata))
19828     process_dynamic_section (filedata);
19829   else
19830     res = FALSE;
19831
19832   if (! process_relocs (filedata))
19833     res = FALSE;
19834
19835   if (! process_unwind (filedata))
19836     res = FALSE;
19837
19838   if (! process_symbol_table (filedata))
19839     res = FALSE;
19840
19841   if (! process_syminfo (filedata))
19842     res = FALSE;
19843
19844   if (! process_version_sections (filedata))
19845     res = FALSE;
19846
19847   if (filedata->file_header.e_shstrndx != SHN_UNDEF)
19848     have_separate_files = load_separate_debug_files (filedata, filedata->file_name);
19849   else
19850     have_separate_files = FALSE;
19851
19852   if (! process_section_contents (filedata))
19853     res = FALSE;
19854
19855   if (have_separate_files)
19856     {
19857       separate_info * d;
19858
19859       for (d = first_separate_info; d != NULL; d = d->next)
19860         {
19861           if (! process_section_headers (d->handle))
19862             res = FALSE;
19863           else if (! process_section_contents (d->handle))
19864             res = FALSE;
19865         }
19866
19867       /* The file handles are closed by the call to free_debug_memory() below.  */
19868     }
19869
19870   if (! process_notes (filedata))
19871     res = FALSE;
19872
19873   if (! process_gnu_liblist (filedata))
19874     res = FALSE;
19875
19876   if (! process_arch_specific (filedata))
19877     res = FALSE;
19878
19879   free (filedata->program_headers);
19880   filedata->program_headers = NULL;
19881
19882   free (filedata->section_headers);
19883   filedata->section_headers = NULL;
19884
19885   free (filedata->string_table);
19886   filedata->string_table = NULL;
19887   filedata->string_table_length = 0;
19888
19889   if (dynamic_strings)
19890     {
19891       free (dynamic_strings);
19892       dynamic_strings = NULL;
19893       dynamic_strings_length = 0;
19894     }
19895
19896   if (dynamic_symbols)
19897     {
19898       free (dynamic_symbols);
19899       dynamic_symbols = NULL;
19900       num_dynamic_syms = 0;
19901     }
19902
19903   if (dynamic_syminfo)
19904     {
19905       free (dynamic_syminfo);
19906       dynamic_syminfo = NULL;
19907     }
19908
19909   if (dynamic_section)
19910     {
19911       free (dynamic_section);
19912       dynamic_section = NULL;
19913     }
19914
19915   if (section_headers_groups)
19916     {
19917       free (section_headers_groups);
19918       section_headers_groups = NULL;
19919     }
19920
19921   if (section_groups)
19922     {
19923       struct group_list * g;
19924       struct group_list * next;
19925
19926       for (i = 0; i < group_count; i++)
19927         {
19928           for (g = section_groups [i].root; g != NULL; g = next)
19929             {
19930               next = g->next;
19931               free (g);
19932             }
19933         }
19934
19935       free (section_groups);
19936       section_groups = NULL;
19937     }
19938
19939   free_debug_memory ();
19940
19941   return res;
19942 }
19943
19944 /* Process an ELF archive.
19945    On entry the file is positioned just after the ARMAG string.
19946    Returns TRUE upon success, FALSE otherwise.  */
19947
19948 static bfd_boolean
19949 process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
19950 {
19951   struct archive_info arch;
19952   struct archive_info nested_arch;
19953   size_t got;
19954   bfd_boolean ret = TRUE;
19955
19956   show_name = TRUE;
19957
19958   /* The ARCH structure is used to hold information about this archive.  */
19959   arch.file_name = NULL;
19960   arch.file = NULL;
19961   arch.index_array = NULL;
19962   arch.sym_table = NULL;
19963   arch.longnames = NULL;
19964
19965   /* The NESTED_ARCH structure is used as a single-item cache of information
19966      about a nested archive (when members of a thin archive reside within
19967      another regular archive file).  */
19968   nested_arch.file_name = NULL;
19969   nested_arch.file = NULL;
19970   nested_arch.index_array = NULL;
19971   nested_arch.sym_table = NULL;
19972   nested_arch.longnames = NULL;
19973
19974   if (setup_archive (&arch, filedata->file_name, filedata->handle,
19975                      is_thin_archive, do_archive_index) != 0)
19976     {
19977       ret = FALSE;
19978       goto out;
19979     }
19980
19981   if (do_archive_index)
19982     {
19983       if (arch.sym_table == NULL)
19984         error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
19985       else
19986         {
19987           unsigned long i, l;
19988           unsigned long current_pos;
19989
19990           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
19991                   filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
19992
19993           current_pos = ftell (filedata->handle);
19994
19995           for (i = l = 0; i < arch.index_num; i++)
19996             {
19997               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
19998                 {
19999                   char * member_name;
20000
20001                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
20002
20003                   if (member_name != NULL)
20004                     {
20005                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
20006
20007                       if (qualified_name != NULL)
20008                         {
20009                           printf (_("Contents of binary %s at offset "), qualified_name);
20010                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
20011                           putchar ('\n');
20012                           free (qualified_name);
20013                         }
20014                     }
20015                 }
20016
20017               if (l >= arch.sym_size)
20018                 {
20019                   error (_("%s: end of the symbol table reached before the end of the index\n"),
20020                          filedata->file_name);
20021                   ret = FALSE;
20022                   break;
20023                 }
20024               /* PR 17531: file: 0b6630b2.  */
20025               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
20026               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
20027             }
20028
20029           if (arch.uses_64bit_indices)
20030             l = (l + 7) & ~ 7;
20031           else
20032             l += l & 1;
20033
20034           if (l < arch.sym_size)
20035             {
20036               error (ngettext ("%s: %ld byte remains in the symbol table, "
20037                                "but without corresponding entries in "
20038                                "the index table\n",
20039                                "%s: %ld bytes remain in the symbol table, "
20040                                "but without corresponding entries in "
20041                                "the index table\n",
20042                                arch.sym_size - l),
20043                      filedata->file_name, arch.sym_size - l);
20044               ret = FALSE;
20045             }
20046
20047           if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
20048             {
20049               error (_("%s: failed to seek back to start of object files in the archive\n"),
20050                      filedata->file_name);
20051               ret = FALSE;
20052               goto out;
20053             }
20054         }
20055
20056       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
20057           && !do_segments && !do_header && !do_dump && !do_version
20058           && !do_histogram && !do_debugging && !do_arch && !do_notes
20059           && !do_section_groups && !do_dyn_syms)
20060         {
20061           ret = TRUE; /* Archive index only.  */
20062           goto out;
20063         }
20064     }
20065
20066   while (1)
20067     {
20068       char * name;
20069       size_t namelen;
20070       char * qualified_name;
20071
20072       /* Read the next archive header.  */
20073       if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
20074         {
20075           error (_("%s: failed to seek to next archive header\n"), arch.file_name);
20076           return FALSE;
20077         }
20078       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
20079       if (got != sizeof arch.arhdr)
20080         {
20081           if (got == 0)
20082             break;
20083           /* PR 24049 - we cannot use filedata->file_name as this will
20084              have already been freed.  */
20085           error (_("%s: failed to read archive header\n"), arch.file_name);
20086
20087           ret = FALSE;
20088           break;
20089         }
20090       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
20091         {
20092           error (_("%s: did not find a valid archive header\n"), arch.file_name);
20093           ret = FALSE;
20094           break;
20095         }
20096
20097       arch.next_arhdr_offset += sizeof arch.arhdr;
20098
20099       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
20100       if (archive_file_size & 01)
20101         ++archive_file_size;
20102
20103       name = get_archive_member_name (&arch, &nested_arch);
20104       if (name == NULL)
20105         {
20106           error (_("%s: bad archive file name\n"), arch.file_name);
20107           ret = FALSE;
20108           break;
20109         }
20110       namelen = strlen (name);
20111
20112       qualified_name = make_qualified_name (&arch, &nested_arch, name);
20113       if (qualified_name == NULL)
20114         {
20115           error (_("%s: bad archive file name\n"), arch.file_name);
20116           ret = FALSE;
20117           break;
20118         }
20119
20120       if (is_thin_archive && arch.nested_member_origin == 0)
20121         {
20122           /* This is a proxy for an external member of a thin archive.  */
20123           Filedata * member_filedata;
20124           char * member_file_name = adjust_relative_path
20125             (filedata->file_name, name, namelen);
20126
20127           if (member_file_name == NULL)
20128             {
20129               ret = FALSE;
20130               break;
20131             }
20132
20133           member_filedata = open_file (member_file_name);
20134           if (member_filedata == NULL)
20135             {
20136               error (_("Input file '%s' is not readable.\n"), member_file_name);
20137               free (member_file_name);
20138               ret = FALSE;
20139               break;
20140             }
20141
20142           archive_file_offset = arch.nested_member_origin;
20143           member_filedata->file_name = qualified_name;
20144
20145           if (! process_object (member_filedata))
20146             ret = FALSE;
20147
20148           close_file (member_filedata);
20149           free (member_file_name);
20150         }
20151       else if (is_thin_archive)
20152         {
20153           Filedata thin_filedata;
20154
20155           memset (&thin_filedata, 0, sizeof (thin_filedata));
20156
20157           /* PR 15140: Allow for corrupt thin archives.  */
20158           if (nested_arch.file == NULL)
20159             {
20160               error (_("%s: contains corrupt thin archive: %s\n"),
20161                      qualified_name, name);
20162               ret = FALSE;
20163               break;
20164             }
20165
20166           /* This is a proxy for a member of a nested archive.  */
20167           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
20168
20169           /* The nested archive file will have been opened and setup by
20170              get_archive_member_name.  */
20171           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
20172             {
20173               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
20174               ret = FALSE;
20175               break;
20176             }
20177
20178           thin_filedata.handle = nested_arch.file;
20179           thin_filedata.file_name = qualified_name;
20180
20181           if (! process_object (& thin_filedata))
20182             ret = FALSE;
20183         }
20184       else
20185         {
20186           archive_file_offset = arch.next_arhdr_offset;
20187           arch.next_arhdr_offset += archive_file_size;
20188
20189           filedata->file_name = qualified_name;
20190           if (! process_object (filedata))
20191             ret = FALSE;
20192         }
20193
20194       if (filedata->dump_sects != NULL)
20195         {
20196           free (filedata->dump_sects);
20197           filedata->dump_sects = NULL;
20198           filedata->num_dump_sects = 0;
20199         }
20200
20201       free (qualified_name);
20202     }
20203
20204  out:
20205   if (nested_arch.file != NULL)
20206     fclose (nested_arch.file);
20207   release_archive (&nested_arch);
20208   release_archive (&arch);
20209
20210   return ret;
20211 }
20212
20213 static bfd_boolean
20214 process_file (char * file_name)
20215 {
20216   Filedata * filedata = NULL;
20217   struct stat statbuf;
20218   char armag[SARMAG];
20219   bfd_boolean ret = TRUE;
20220
20221   if (stat (file_name, &statbuf) < 0)
20222     {
20223       if (errno == ENOENT)
20224         error (_("'%s': No such file\n"), file_name);
20225       else
20226         error (_("Could not locate '%s'.  System error message: %s\n"),
20227                file_name, strerror (errno));
20228       return FALSE;
20229     }
20230
20231   if (! S_ISREG (statbuf.st_mode))
20232     {
20233       error (_("'%s' is not an ordinary file\n"), file_name);
20234       return FALSE;
20235     }
20236
20237   filedata = calloc (1, sizeof * filedata);
20238   if (filedata == NULL)
20239     {
20240       error (_("Out of memory allocating file data structure\n"));
20241       return FALSE;
20242     }
20243
20244   filedata->file_name = file_name;
20245   filedata->handle = fopen (file_name, "rb");
20246   if (filedata->handle == NULL)
20247     {
20248       error (_("Input file '%s' is not readable.\n"), file_name);
20249       free (filedata);
20250       return FALSE;
20251     }
20252
20253   if (fread (armag, SARMAG, 1, filedata->handle) != 1)
20254     {
20255       error (_("%s: Failed to read file's magic number\n"), file_name);
20256       fclose (filedata->handle);
20257       free (filedata);
20258       return FALSE;
20259     }
20260
20261   filedata->file_size = (bfd_size_type) statbuf.st_size;
20262
20263   if (memcmp (armag, ARMAG, SARMAG) == 0)
20264     {
20265       if (! process_archive (filedata, FALSE))
20266         ret = FALSE;
20267     }
20268   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
20269     {
20270       if ( ! process_archive (filedata, TRUE))
20271         ret = FALSE;
20272     }
20273   else
20274     {
20275       if (do_archive_index)
20276         error (_("File %s is not an archive so its index cannot be displayed.\n"),
20277                file_name);
20278
20279       rewind (filedata->handle);
20280       archive_file_size = archive_file_offset = 0;
20281
20282       if (! process_object (filedata))
20283         ret = FALSE;
20284     }
20285
20286   fclose (filedata->handle);
20287   free (filedata);
20288
20289   return ret;
20290 }
20291
20292 #ifdef SUPPORT_DISASSEMBLY
20293 /* Needed by the i386 disassembler.  For extra credit, someone could
20294    fix this so that we insert symbolic addresses here, esp for GOT/PLT
20295    symbols.  */
20296
20297 void
20298 print_address (unsigned int addr, FILE * outfile)
20299 {
20300   fprintf (outfile,"0x%8.8x", addr);
20301 }
20302
20303 /* Needed by the i386 disassembler.  */
20304
20305 void
20306 db_task_printsym (unsigned int addr)
20307 {
20308   print_address (addr, stderr);
20309 }
20310 #endif
20311
20312 int
20313 main (int argc, char ** argv)
20314 {
20315   int err;
20316
20317 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20318   setlocale (LC_MESSAGES, "");
20319 #endif
20320 #if defined (HAVE_SETLOCALE)
20321   setlocale (LC_CTYPE, "");
20322 #endif
20323   bindtextdomain (PACKAGE, LOCALEDIR);
20324   textdomain (PACKAGE);
20325
20326   expandargv (&argc, &argv);
20327
20328   cmdline.file_name = "<cmdline>";
20329   parse_args (& cmdline, argc, argv);
20330
20331   if (optind < (argc - 1))
20332     show_name = TRUE;
20333   else if (optind >= argc)
20334     {
20335       warn (_("Nothing to do.\n"));
20336       usage (stderr);
20337     }
20338
20339   err = FALSE;
20340   while (optind < argc)
20341     if (! process_file (argv[optind++]))
20342       err = TRUE;
20343
20344   if (cmdline.dump_sects != NULL)
20345     free (cmdline.dump_sects);
20346
20347   free (dump_ctf_symtab_name);
20348   free (dump_ctf_strtab_name);
20349   free (dump_ctf_parent_name);
20350
20351   return err ? EXIT_FAILURE : EXIT_SUCCESS;
20352 }