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   if (filedata->file_header.e_phnum == 0)
5105     {
5106       /* PR binutils/12467.  */
5107       if (filedata->file_header.e_phoff != 0)
5108         {
5109           warn (_("possibly corrupt ELF header - it has a non-zero program"
5110                   " header offset, but no program headers\n"));
5111           return FALSE;
5112         }
5113       else if (do_segments)
5114         printf (_("\nThere are no program headers in this file.\n"));
5115       return TRUE;
5116     }
5117
5118   if (do_segments && !do_header)
5119     {
5120       printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
5121       printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
5122       printf (ngettext ("There is %d program header, starting at offset %s\n",
5123                         "There are %d program headers, starting at offset %s\n",
5124                         filedata->file_header.e_phnum),
5125               filedata->file_header.e_phnum,
5126               bfd_vmatoa ("u", filedata->file_header.e_phoff));
5127     }
5128
5129   if (! get_program_headers (filedata))
5130     return TRUE;
5131
5132   if (do_segments)
5133     {
5134       if (filedata->file_header.e_phnum > 1)
5135         printf (_("\nProgram Headers:\n"));
5136       else
5137         printf (_("\nProgram Headers:\n"));
5138
5139       if (is_32bit_elf)
5140         printf
5141           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
5142       else if (do_wide)
5143         printf
5144           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
5145       else
5146         {
5147           printf
5148             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
5149           printf
5150             (_("                 FileSiz            MemSiz              Flags  Align\n"));
5151         }
5152     }
5153
5154   dynamic_addr = 0;
5155   dynamic_size = 0;
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   max_vd_ndx = 0;
11532
11533   /* Usually we'd only see verdef for defined symbols, and verneed for
11534      undefined symbols.  However, symbols defined by the linker in
11535      .dynbss for variables copied from a shared library in order to
11536      avoid text relocations are defined yet have verneed.  We could
11537      use a heuristic to detect the special case, for example, check
11538      for verneed first on symbols defined in SHT_NOBITS sections, but
11539      it is simpler and more reliable to just look for both verdef and
11540      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
11541
11542   if (psym->st_shndx != SHN_UNDEF
11543       && vers_data != 0x8001
11544       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11545     {
11546       Elf_Internal_Verdef ivd;
11547       Elf_Internal_Verdaux ivda;
11548       Elf_External_Verdaux evda;
11549       unsigned long off;
11550
11551       off = offset_from_vma (filedata,
11552                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11553                              sizeof (Elf_External_Verdef));
11554
11555       do
11556         {
11557           Elf_External_Verdef evd;
11558
11559           if (get_data (&evd, filedata, off, sizeof (evd), 1,
11560                         _("version def")) == NULL)
11561             {
11562               ivd.vd_ndx = 0;
11563               ivd.vd_aux = 0;
11564               ivd.vd_next = 0;
11565               ivd.vd_flags = 0;
11566             }
11567           else
11568             {
11569               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11570               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11571               ivd.vd_next = BYTE_GET (evd.vd_next);
11572               ivd.vd_flags = BYTE_GET (evd.vd_flags);
11573             }
11574
11575           if ((ivd.vd_ndx & VERSYM_VERSION) > max_vd_ndx)
11576             max_vd_ndx = ivd.vd_ndx & VERSYM_VERSION;
11577
11578           off += ivd.vd_next;
11579         }
11580       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11581
11582       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11583         {
11584           if (ivd.vd_ndx == 1 && ivd.vd_flags == VER_FLG_BASE)
11585             return NULL;
11586
11587           off -= ivd.vd_next;
11588           off += ivd.vd_aux;
11589
11590           if (get_data (&evda, filedata, off, sizeof (evda), 1,
11591                         _("version def aux")) != NULL)
11592             {
11593               ivda.vda_name = BYTE_GET (evda.vda_name);
11594
11595               if (psym->st_name != ivda.vda_name)
11596                 {
11597                   *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11598                                ? symbol_hidden : symbol_public);
11599                   return (ivda.vda_name < strtab_size
11600                           ? strtab + ivda.vda_name : _("<corrupt>"));
11601                 }
11602             }
11603         }
11604     }
11605
11606   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11607     {
11608       Elf_External_Verneed evn;
11609       Elf_Internal_Verneed ivn;
11610       Elf_Internal_Vernaux ivna;
11611
11612       offset = offset_from_vma (filedata,
11613                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11614                                 sizeof evn);
11615       do
11616         {
11617           unsigned long vna_off;
11618
11619           if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11620                         _("version need")) == NULL)
11621             {
11622               ivna.vna_next = 0;
11623               ivna.vna_other = 0;
11624               ivna.vna_name = 0;
11625               break;
11626             }
11627
11628           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
11629           ivn.vn_next = BYTE_GET (evn.vn_next);
11630
11631           vna_off = offset + ivn.vn_aux;
11632
11633           do
11634             {
11635               Elf_External_Vernaux evna;
11636
11637               if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11638                             _("version need aux (3)")) == NULL)
11639                 {
11640                   ivna.vna_next = 0;
11641                   ivna.vna_other = 0;
11642                   ivna.vna_name = 0;
11643                 }
11644               else
11645                 {
11646                   ivna.vna_other = BYTE_GET (evna.vna_other);
11647                   ivna.vna_next  = BYTE_GET (evna.vna_next);
11648                   ivna.vna_name  = BYTE_GET (evna.vna_name);
11649                 }
11650
11651               vna_off += ivna.vna_next;
11652             }
11653           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11654
11655           if (ivna.vna_other == vers_data)
11656             break;
11657
11658           offset += ivn.vn_next;
11659         }
11660       while (ivn.vn_next != 0);
11661
11662       if (ivna.vna_other == vers_data)
11663         {
11664           *sym_info = symbol_undefined;
11665           *vna_other = ivna.vna_other;
11666           return (ivna.vna_name < strtab_size
11667                   ? strtab + ivna.vna_name : _("<corrupt>"));
11668         }
11669       else if ((max_vd_ndx || (vers_data & VERSYM_VERSION) != 1)
11670                && (vers_data & VERSYM_VERSION) > max_vd_ndx)
11671         return _("<corrupt>");
11672     }
11673   return NULL;
11674 }
11675
11676 /* Dump the symbol table.  */
11677 static bfd_boolean
11678 process_symbol_table (Filedata * filedata)
11679 {
11680   Elf_Internal_Shdr * section;
11681   bfd_size_type nbuckets = 0;
11682   bfd_size_type nchains = 0;
11683   bfd_vma * buckets = NULL;
11684   bfd_vma * chains = NULL;
11685   bfd_vma ngnubuckets = 0;
11686   bfd_vma * gnubuckets = NULL;
11687   bfd_vma * gnuchains = NULL;
11688   bfd_vma * mipsxlat = NULL;
11689   bfd_vma gnusymidx = 0;
11690   bfd_size_type ngnuchains = 0;
11691
11692   if (!do_syms && !do_dyn_syms && !do_histogram)
11693     return TRUE;
11694
11695   if (dynamic_info[DT_HASH]
11696       && (do_histogram
11697           || (do_using_dynamic
11698               && !do_dyn_syms
11699               && dynamic_strings != NULL)))
11700     {
11701       unsigned char nb[8];
11702       unsigned char nc[8];
11703       unsigned int hash_ent_size = 4;
11704
11705       if ((filedata->file_header.e_machine == EM_ALPHA
11706            || filedata->file_header.e_machine == EM_S390
11707            || filedata->file_header.e_machine == EM_S390_OLD)
11708           && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11709         hash_ent_size = 8;
11710
11711       if (fseek (filedata->handle,
11712                  (archive_file_offset
11713                   + offset_from_vma (filedata, dynamic_info[DT_HASH],
11714                                      sizeof nb + sizeof nc)),
11715                  SEEK_SET))
11716         {
11717           error (_("Unable to seek to start of dynamic information\n"));
11718           goto no_hash;
11719         }
11720
11721       if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11722         {
11723           error (_("Failed to read in number of buckets\n"));
11724           goto no_hash;
11725         }
11726
11727       if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11728         {
11729           error (_("Failed to read in number of chains\n"));
11730           goto no_hash;
11731         }
11732
11733       nbuckets = byte_get (nb, hash_ent_size);
11734       nchains  = byte_get (nc, hash_ent_size);
11735
11736       buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11737       chains  = get_dynamic_data (filedata, nchains, hash_ent_size);
11738
11739     no_hash:
11740       if (buckets == NULL || chains == NULL)
11741         {
11742           if (do_using_dynamic)
11743             return FALSE;
11744           free (buckets);
11745           free (chains);
11746           buckets = NULL;
11747           chains = NULL;
11748           nbuckets = 0;
11749           nchains = 0;
11750         }
11751     }
11752
11753   if (dynamic_info_DT_GNU_HASH
11754       && (do_histogram
11755           || (do_using_dynamic
11756               && !do_dyn_syms
11757               && dynamic_strings != NULL)))
11758     {
11759       unsigned char nb[16];
11760       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11761       bfd_vma buckets_vma;
11762
11763       if (fseek (filedata->handle,
11764                  (archive_file_offset
11765                   + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11766                                      sizeof nb)),
11767                  SEEK_SET))
11768         {
11769           error (_("Unable to seek to start of dynamic information\n"));
11770           goto no_gnu_hash;
11771         }
11772
11773       if (fread (nb, 16, 1, filedata->handle) != 1)
11774         {
11775           error (_("Failed to read in number of buckets\n"));
11776           goto no_gnu_hash;
11777         }
11778
11779       ngnubuckets = byte_get (nb, 4);
11780       gnusymidx = byte_get (nb + 4, 4);
11781       bitmaskwords = byte_get (nb + 8, 4);
11782       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11783       if (is_32bit_elf)
11784         buckets_vma += bitmaskwords * 4;
11785       else
11786         buckets_vma += bitmaskwords * 8;
11787
11788       if (fseek (filedata->handle,
11789                  (archive_file_offset
11790                   + offset_from_vma (filedata, buckets_vma, 4)),
11791                  SEEK_SET))
11792         {
11793           error (_("Unable to seek to start of dynamic information\n"));
11794           goto no_gnu_hash;
11795         }
11796
11797       gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11798
11799       if (gnubuckets == NULL)
11800         goto no_gnu_hash;
11801
11802       for (i = 0; i < ngnubuckets; i++)
11803         if (gnubuckets[i] != 0)
11804           {
11805             if (gnubuckets[i] < gnusymidx)
11806               return FALSE;
11807
11808             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11809               maxchain = gnubuckets[i];
11810           }
11811
11812       if (maxchain == 0xffffffff)
11813         goto no_gnu_hash;
11814
11815       maxchain -= gnusymidx;
11816
11817       if (fseek (filedata->handle,
11818                  (archive_file_offset
11819                   + offset_from_vma (filedata, buckets_vma
11820                                            + 4 * (ngnubuckets + maxchain), 4)),
11821                  SEEK_SET))
11822         {
11823           error (_("Unable to seek to start of dynamic information\n"));
11824           goto no_gnu_hash;
11825         }
11826
11827       do
11828         {
11829           if (fread (nb, 4, 1, filedata->handle) != 1)
11830             {
11831               error (_("Failed to determine last chain length\n"));
11832               goto no_gnu_hash;
11833             }
11834
11835           if (maxchain + 1 == 0)
11836             goto no_gnu_hash;
11837
11838           ++maxchain;
11839         }
11840       while ((byte_get (nb, 4) & 1) == 0);
11841
11842       if (fseek (filedata->handle,
11843                  (archive_file_offset
11844                   + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11845                  SEEK_SET))
11846         {
11847           error (_("Unable to seek to start of dynamic information\n"));
11848           goto no_gnu_hash;
11849         }
11850
11851       gnuchains = get_dynamic_data (filedata, maxchain, 4);
11852       ngnuchains = maxchain;
11853
11854       if (gnuchains == NULL)
11855         goto no_gnu_hash;
11856
11857       if (dynamic_info_DT_MIPS_XHASH)
11858         {
11859           if (fseek (filedata->handle,
11860                      (archive_file_offset
11861                       + offset_from_vma (filedata, (buckets_vma
11862                                                     + 4 * (ngnubuckets
11863                                                            + maxchain)), 4)),
11864                      SEEK_SET))
11865             {
11866               error (_("Unable to seek to start of dynamic information\n"));
11867               goto no_gnu_hash;
11868             }
11869
11870           mipsxlat = get_dynamic_data (filedata, maxchain, 4);
11871         }
11872
11873     no_gnu_hash:
11874       if (dynamic_info_DT_MIPS_XHASH && mipsxlat == NULL)
11875         {
11876           free (gnuchains);
11877           gnuchains = NULL;
11878         }
11879       if (gnuchains == NULL)
11880         {
11881           free (gnubuckets);
11882           gnubuckets = NULL;
11883           ngnubuckets = 0;
11884           if (do_using_dynamic)
11885             return FALSE;
11886         }
11887     }
11888
11889   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11890       && do_syms
11891       && do_using_dynamic
11892       && dynamic_strings != NULL
11893       && dynamic_symbols != NULL)
11894     {
11895       unsigned long hn;
11896
11897       if (dynamic_info[DT_HASH])
11898         {
11899           bfd_vma si;
11900           char *visited;
11901
11902           printf (_("\nSymbol table for image:\n"));
11903           if (is_32bit_elf)
11904             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11905           else
11906             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11907
11908           visited = xcmalloc (nchains, 1);
11909           memset (visited, 0, nchains);
11910           for (hn = 0; hn < nbuckets; hn++)
11911             {
11912               for (si = buckets[hn]; si > 0; si = chains[si])
11913                 {
11914                   print_dynamic_symbol (filedata, si, hn);
11915                   if (si >= nchains || visited[si])
11916                     {
11917                       error (_("histogram chain is corrupt\n"));
11918                       break;
11919                     }
11920                   visited[si] = 1;
11921                 }
11922             }
11923           free (visited);
11924         }
11925
11926       if (dynamic_info_DT_GNU_HASH)
11927         {
11928           printf (_("\nSymbol table of `%s' for image:\n"),
11929                   GNU_HASH_SECTION_NAME);
11930           if (is_32bit_elf)
11931             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11932           else
11933             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11934
11935           for (hn = 0; hn < ngnubuckets; ++hn)
11936             if (gnubuckets[hn] != 0)
11937               {
11938                 bfd_vma si = gnubuckets[hn];
11939                 bfd_vma off = si - gnusymidx;
11940
11941                 do
11942                   {
11943                     if (dynamic_info_DT_MIPS_XHASH)
11944                       print_dynamic_symbol (filedata, mipsxlat[off], hn);
11945                     else
11946                       print_dynamic_symbol (filedata, si, hn);
11947                     si++;
11948                   }
11949                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11950               }
11951         }
11952     }
11953   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11954            && filedata->section_headers != NULL)
11955     {
11956       unsigned int i;
11957
11958       for (i = 0, section = filedata->section_headers;
11959            i < filedata->file_header.e_shnum;
11960            i++, section++)
11961         {
11962           unsigned int si;
11963           char * strtab = NULL;
11964           unsigned long int strtab_size = 0;
11965           Elf_Internal_Sym * symtab;
11966           Elf_Internal_Sym * psym;
11967           unsigned long num_syms;
11968
11969           if ((section->sh_type != SHT_SYMTAB
11970                && section->sh_type != SHT_DYNSYM)
11971               || (!do_syms
11972                   && section->sh_type == SHT_SYMTAB))
11973             continue;
11974
11975           if (section->sh_entsize == 0)
11976             {
11977               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11978                       printable_section_name (filedata, section));
11979               continue;
11980             }
11981
11982           num_syms = section->sh_size / section->sh_entsize;
11983           printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11984                             "\nSymbol table '%s' contains %lu entries:\n",
11985                             num_syms),
11986                   printable_section_name (filedata, section),
11987                   num_syms);
11988
11989           if (is_32bit_elf)
11990             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
11991           else
11992             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
11993
11994           symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
11995           if (symtab == NULL)
11996             continue;
11997
11998           if (section->sh_link == filedata->file_header.e_shstrndx)
11999             {
12000               strtab = filedata->string_table;
12001               strtab_size = filedata->string_table_length;
12002             }
12003           else if (section->sh_link < filedata->file_header.e_shnum)
12004             {
12005               Elf_Internal_Shdr * string_sec;
12006
12007               string_sec = filedata->section_headers + section->sh_link;
12008
12009               strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
12010                                           1, string_sec->sh_size,
12011                                           _("string table"));
12012               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
12013             }
12014
12015           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
12016             {
12017               const char *version_string;
12018               enum versioned_symbol_info sym_info;
12019               unsigned short vna_other;
12020
12021               printf ("%6d: ", si);
12022               print_vma (psym->st_value, LONG_HEX);
12023               putchar (' ');
12024               print_vma (psym->st_size, DEC_5);
12025               printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
12026               printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
12027               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
12028                 printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
12029               else
12030                 {
12031                   unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
12032
12033                   printf (" %-7s", get_symbol_visibility (vis));
12034                   /* Check to see if any other bits in the st_other field are set.
12035                      Note - displaying this information disrupts the layout of the
12036                      table being generated, but for the moment this case is very rare.  */
12037                   if (psym->st_other ^ vis)
12038                     printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
12039                 }
12040               printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
12041               print_symbol (25, psym->st_name < strtab_size
12042                             ? strtab + psym->st_name : _("<corrupt>"));
12043
12044               version_string
12045                 = get_symbol_version_string (filedata,
12046                                              section->sh_type == SHT_DYNSYM,
12047                                              strtab, strtab_size, si,
12048                                              psym, &sym_info, &vna_other);
12049               if (version_string)
12050                 {
12051                   if (sym_info == symbol_undefined)
12052                     printf ("@%s (%d)", version_string, vna_other);
12053                   else
12054                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
12055                             version_string);
12056                 }
12057
12058               putchar ('\n');
12059
12060               if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
12061                   && si >= section->sh_info
12062                   /* Irix 5 and 6 MIPS binaries are known to ignore this requirement.  */
12063                   && filedata->file_header.e_machine != EM_MIPS
12064                   /* Solaris binaries have been found to violate this requirement as
12065                      well.  Not sure if this is a bug or an ABI requirement.  */
12066                   && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
12067                 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
12068                       si, printable_section_name (filedata, section), section->sh_info);
12069             }
12070
12071           free (symtab);
12072           if (strtab != filedata->string_table)
12073             free (strtab);
12074         }
12075     }
12076   else if (do_syms)
12077     printf
12078       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12079
12080   if (do_histogram && buckets != NULL)
12081     {
12082       unsigned long * lengths;
12083       unsigned long * counts;
12084       unsigned long hn;
12085       bfd_vma si;
12086       unsigned long maxlength = 0;
12087       unsigned long nzero_counts = 0;
12088       unsigned long nsyms = 0;
12089       char *visited;
12090
12091       printf (ngettext ("\nHistogram for bucket list length "
12092                         "(total of %lu bucket):\n",
12093                         "\nHistogram for bucket list length "
12094                         "(total of %lu buckets):\n",
12095                         (unsigned long) nbuckets),
12096               (unsigned long) nbuckets);
12097
12098       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
12099       if (lengths == NULL)
12100         {
12101           error (_("Out of memory allocating space for histogram buckets\n"));
12102           return FALSE;
12103         }
12104       visited = xcmalloc (nchains, 1);
12105       memset (visited, 0, nchains);
12106
12107       printf (_(" Length  Number     %% of total  Coverage\n"));
12108       for (hn = 0; hn < nbuckets; ++hn)
12109         {
12110           for (si = buckets[hn]; si > 0; si = chains[si])
12111             {
12112               ++nsyms;
12113               if (maxlength < ++lengths[hn])
12114                 ++maxlength;
12115               if (si >= nchains || visited[si])
12116                 {
12117                   error (_("histogram chain is corrupt\n"));
12118                   break;
12119                 }
12120               visited[si] = 1;
12121             }
12122         }
12123       free (visited);
12124
12125       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
12126       if (counts == NULL)
12127         {
12128           free (lengths);
12129           error (_("Out of memory allocating space for histogram counts\n"));
12130           return FALSE;
12131         }
12132
12133       for (hn = 0; hn < nbuckets; ++hn)
12134         ++counts[lengths[hn]];
12135
12136       if (nbuckets > 0)
12137         {
12138           unsigned long i;
12139           printf ("      0  %-10lu (%5.1f%%)\n",
12140                   counts[0], (counts[0] * 100.0) / nbuckets);
12141           for (i = 1; i <= maxlength; ++i)
12142             {
12143               nzero_counts += counts[i] * i;
12144               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
12145                       i, counts[i], (counts[i] * 100.0) / nbuckets,
12146                       (nzero_counts * 100.0) / nsyms);
12147             }
12148         }
12149
12150       free (counts);
12151       free (lengths);
12152     }
12153
12154   if (buckets != NULL)
12155     {
12156       free (buckets);
12157       free (chains);
12158     }
12159
12160   if (do_histogram && gnubuckets != NULL)
12161     {
12162       unsigned long * lengths;
12163       unsigned long * counts;
12164       unsigned long hn;
12165       unsigned long maxlength = 0;
12166       unsigned long nzero_counts = 0;
12167       unsigned long nsyms = 0;
12168
12169       printf (ngettext ("\nHistogram for `%s' bucket list length "
12170                         "(total of %lu bucket):\n",
12171                         "\nHistogram for `%s' bucket list length "
12172                         "(total of %lu buckets):\n",
12173                         (unsigned long) ngnubuckets),
12174               GNU_HASH_SECTION_NAME,
12175               (unsigned long) ngnubuckets);
12176
12177       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
12178       if (lengths == NULL)
12179         {
12180           error (_("Out of memory allocating space for gnu histogram buckets\n"));
12181           return FALSE;
12182         }
12183
12184       printf (_(" Length  Number     %% of total  Coverage\n"));
12185
12186       for (hn = 0; hn < ngnubuckets; ++hn)
12187         if (gnubuckets[hn] != 0)
12188           {
12189             bfd_vma off, length = 1;
12190
12191             for (off = gnubuckets[hn] - gnusymidx;
12192                  /* PR 17531 file: 010-77222-0.004.  */
12193                  off < ngnuchains && (gnuchains[off] & 1) == 0;
12194                  ++off)
12195               ++length;
12196             lengths[hn] = length;
12197             if (length > maxlength)
12198               maxlength = length;
12199             nsyms += length;
12200           }
12201
12202       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
12203       if (counts == NULL)
12204         {
12205           free (lengths);
12206           error (_("Out of memory allocating space for gnu histogram counts\n"));
12207           return FALSE;
12208         }
12209
12210       for (hn = 0; hn < ngnubuckets; ++hn)
12211         ++counts[lengths[hn]];
12212
12213       if (ngnubuckets > 0)
12214         {
12215           unsigned long j;
12216           printf ("      0  %-10lu (%5.1f%%)\n",
12217                   counts[0], (counts[0] * 100.0) / ngnubuckets);
12218           for (j = 1; j <= maxlength; ++j)
12219             {
12220               nzero_counts += counts[j] * j;
12221               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
12222                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
12223                       (nzero_counts * 100.0) / nsyms);
12224             }
12225         }
12226
12227       free (counts);
12228       free (lengths);
12229       free (gnubuckets);
12230       free (gnuchains);
12231       free (mipsxlat);
12232     }
12233
12234   return TRUE;
12235 }
12236
12237 static bfd_boolean
12238 process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
12239 {
12240   unsigned int i;
12241
12242   if (dynamic_syminfo == NULL
12243       || !do_dynamic)
12244     /* No syminfo, this is ok.  */
12245     return TRUE;
12246
12247   /* There better should be a dynamic symbol section.  */
12248   if (dynamic_symbols == NULL || dynamic_strings == NULL)
12249     return FALSE;
12250
12251   if (dynamic_addr)
12252     printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12253                       "contains %d entry:\n",
12254                       "\nDynamic info segment at offset 0x%lx "
12255                       "contains %d entries:\n",
12256                       dynamic_syminfo_nent),
12257             dynamic_syminfo_offset, dynamic_syminfo_nent);
12258
12259   printf (_(" Num: Name                           BoundTo     Flags\n"));
12260   for (i = 0; i < dynamic_syminfo_nent; ++i)
12261     {
12262       unsigned short int flags = dynamic_syminfo[i].si_flags;
12263
12264       printf ("%4d: ", i);
12265       if (i >= num_dynamic_syms)
12266         printf (_("<corrupt index>"));
12267       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
12268         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
12269       else
12270         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
12271       putchar (' ');
12272
12273       switch (dynamic_syminfo[i].si_boundto)
12274         {
12275         case SYMINFO_BT_SELF:
12276           fputs ("SELF       ", stdout);
12277           break;
12278         case SYMINFO_BT_PARENT:
12279           fputs ("PARENT     ", stdout);
12280           break;
12281         default:
12282           if (dynamic_syminfo[i].si_boundto > 0
12283               && dynamic_syminfo[i].si_boundto < dynamic_nent
12284               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
12285             {
12286               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
12287               putchar (' ' );
12288             }
12289           else
12290             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
12291           break;
12292         }
12293
12294       if (flags & SYMINFO_FLG_DIRECT)
12295         printf (" DIRECT");
12296       if (flags & SYMINFO_FLG_PASSTHRU)
12297         printf (" PASSTHRU");
12298       if (flags & SYMINFO_FLG_COPY)
12299         printf (" COPY");
12300       if (flags & SYMINFO_FLG_LAZYLOAD)
12301         printf (" LAZYLOAD");
12302
12303       puts ("");
12304     }
12305
12306   return TRUE;
12307 }
12308
12309 #define IN_RANGE(START,END,ADDR,OFF)            \
12310   (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12311
12312 /* Check to see if the given reloc needs to be handled in a target specific
12313    manner.  If so then process the reloc and return TRUE otherwise return
12314    FALSE.
12315
12316    If called with reloc == NULL, then this is a signal that reloc processing
12317    for the current section has finished, and any saved state should be
12318    discarded.  */
12319
12320 static bfd_boolean
12321 target_specific_reloc_handling (Filedata *           filedata,
12322                                 Elf_Internal_Rela *  reloc,
12323                                 unsigned char *      start,
12324                                 unsigned char *      end,
12325                                 Elf_Internal_Sym *   symtab,
12326                                 unsigned long        num_syms)
12327 {
12328   unsigned int reloc_type = 0;
12329   unsigned long sym_index = 0;
12330
12331   if (reloc)
12332     {
12333       reloc_type = get_reloc_type (filedata, reloc->r_info);
12334       sym_index = get_reloc_symindex (reloc->r_info);
12335     }
12336
12337   switch (filedata->file_header.e_machine)
12338     {
12339     case EM_MSP430:
12340     case EM_MSP430_OLD:
12341       {
12342         static Elf_Internal_Sym * saved_sym = NULL;
12343
12344         if (reloc == NULL)
12345           {
12346             saved_sym = NULL;
12347             return TRUE;
12348           }
12349
12350         switch (reloc_type)
12351           {
12352           case 10: /* R_MSP430_SYM_DIFF */
12353             if (uses_msp430x_relocs (filedata))
12354               break;
12355             /* Fall through.  */
12356           case 21: /* R_MSP430X_SYM_DIFF */
12357             /* PR 21139.  */
12358             if (sym_index >= num_syms)
12359               error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12360                      sym_index);
12361             else
12362               saved_sym = symtab + sym_index;
12363             return TRUE;
12364
12365           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12366           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12367             goto handle_sym_diff;
12368
12369           case 5: /* R_MSP430_16_BYTE */
12370           case 9: /* R_MSP430_8 */
12371             if (uses_msp430x_relocs (filedata))
12372               break;
12373             goto handle_sym_diff;
12374
12375           case 2: /* R_MSP430_ABS16 */
12376           case 15: /* R_MSP430X_ABS16 */
12377             if (! uses_msp430x_relocs (filedata))
12378               break;
12379             goto handle_sym_diff;
12380
12381           handle_sym_diff:
12382             if (saved_sym != NULL)
12383               {
12384                 int reloc_size = reloc_type == 1 ? 4 : 2;
12385                 bfd_vma value;
12386
12387                 if (sym_index >= num_syms)
12388                   error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12389                          sym_index);
12390                 else
12391                   {
12392                     value = reloc->r_addend + (symtab[sym_index].st_value
12393                                                - saved_sym->st_value);
12394
12395                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12396                       byte_put (start + reloc->r_offset, value, reloc_size);
12397                     else
12398                       /* PR 21137 */
12399                       error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12400                              (long) reloc->r_offset);
12401                   }
12402
12403                 saved_sym = NULL;
12404                 return TRUE;
12405               }
12406             break;
12407
12408           default:
12409             if (saved_sym != NULL)
12410               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12411             break;
12412           }
12413         break;
12414       }
12415
12416     case EM_MN10300:
12417     case EM_CYGNUS_MN10300:
12418       {
12419         static Elf_Internal_Sym * saved_sym = NULL;
12420
12421         if (reloc == NULL)
12422           {
12423             saved_sym = NULL;
12424             return TRUE;
12425           }
12426
12427         switch (reloc_type)
12428           {
12429           case 34: /* R_MN10300_ALIGN */
12430             return TRUE;
12431           case 33: /* R_MN10300_SYM_DIFF */
12432             if (sym_index >= num_syms)
12433               error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12434                      sym_index);
12435             else
12436               saved_sym = symtab + sym_index;
12437             return TRUE;
12438
12439           case 1: /* R_MN10300_32 */
12440           case 2: /* R_MN10300_16 */
12441             if (saved_sym != NULL)
12442               {
12443                 int reloc_size = reloc_type == 1 ? 4 : 2;
12444                 bfd_vma value;
12445
12446                 if (sym_index >= num_syms)
12447                   error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12448                          sym_index);
12449                 else
12450                   {
12451                     value = reloc->r_addend + (symtab[sym_index].st_value
12452                                                - saved_sym->st_value);
12453
12454                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12455                       byte_put (start + reloc->r_offset, value, reloc_size);
12456                     else
12457                       error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12458                              (long) reloc->r_offset);
12459                   }
12460
12461                 saved_sym = NULL;
12462                 return TRUE;
12463               }
12464             break;
12465           default:
12466             if (saved_sym != NULL)
12467               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12468             break;
12469           }
12470         break;
12471       }
12472
12473     case EM_RL78:
12474       {
12475         static bfd_vma saved_sym1 = 0;
12476         static bfd_vma saved_sym2 = 0;
12477         static bfd_vma value;
12478
12479         if (reloc == NULL)
12480           {
12481             saved_sym1 = saved_sym2 = 0;
12482             return TRUE;
12483           }
12484
12485         switch (reloc_type)
12486           {
12487           case 0x80: /* R_RL78_SYM.  */
12488             saved_sym1 = saved_sym2;
12489             if (sym_index >= num_syms)
12490               error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12491                      sym_index);
12492             else
12493               {
12494                 saved_sym2 = symtab[sym_index].st_value;
12495                 saved_sym2 += reloc->r_addend;
12496               }
12497             return TRUE;
12498
12499           case 0x83: /* R_RL78_OPsub.  */
12500             value = saved_sym1 - saved_sym2;
12501             saved_sym2 = saved_sym1 = 0;
12502             return TRUE;
12503             break;
12504
12505           case 0x41: /* R_RL78_ABS32.  */
12506             if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12507               byte_put (start + reloc->r_offset, value, 4);
12508             else
12509               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12510                      (long) reloc->r_offset);
12511             value = 0;
12512             return TRUE;
12513
12514           case 0x43: /* R_RL78_ABS16.  */
12515             if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12516               byte_put (start + reloc->r_offset, value, 2);
12517             else
12518               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12519                      (long) reloc->r_offset);
12520             value = 0;
12521             return TRUE;
12522
12523           default:
12524             break;
12525           }
12526         break;
12527       }
12528     }
12529
12530   return FALSE;
12531 }
12532
12533 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12534    DWARF debug sections.  This is a target specific test.  Note - we do not
12535    go through the whole including-target-headers-multiple-times route, (as
12536    we have already done with <elf/h8.h>) because this would become very
12537    messy and even then this function would have to contain target specific
12538    information (the names of the relocs instead of their numeric values).
12539    FIXME: This is not the correct way to solve this problem.  The proper way
12540    is to have target specific reloc sizing and typing functions created by
12541    the reloc-macros.h header, in the same way that it already creates the
12542    reloc naming functions.  */
12543
12544 static bfd_boolean
12545 is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12546 {
12547   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12548   switch (filedata->file_header.e_machine)
12549     {
12550     case EM_386:
12551     case EM_IAMCU:
12552       return reloc_type == 1; /* R_386_32.  */
12553     case EM_68K:
12554       return reloc_type == 1; /* R_68K_32.  */
12555     case EM_860:
12556       return reloc_type == 1; /* R_860_32.  */
12557     case EM_960:
12558       return reloc_type == 2; /* R_960_32.  */
12559     case EM_AARCH64:
12560       return (reloc_type == 258
12561               || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12562     case EM_BPF:
12563       return reloc_type == 11; /* R_BPF_DATA_32 */
12564     case EM_ADAPTEVA_EPIPHANY:
12565       return reloc_type == 3;
12566     case EM_ALPHA:
12567       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
12568     case EM_ARC:
12569       return reloc_type == 1; /* R_ARC_32.  */
12570     case EM_ARC_COMPACT:
12571     case EM_ARC_COMPACT2:
12572       return reloc_type == 4; /* R_ARC_32.  */
12573     case EM_ARM:
12574       return reloc_type == 2; /* R_ARM_ABS32 */
12575     case EM_AVR_OLD:
12576     case EM_AVR:
12577       return reloc_type == 1;
12578     case EM_BLACKFIN:
12579       return reloc_type == 0x12; /* R_byte4_data.  */
12580     case EM_CRIS:
12581       return reloc_type == 3; /* R_CRIS_32.  */
12582     case EM_CR16:
12583       return reloc_type == 3; /* R_CR16_NUM32.  */
12584     case EM_CRX:
12585       return reloc_type == 15; /* R_CRX_NUM32.  */
12586     case EM_CSKY:
12587       return reloc_type == 1; /* R_CKCORE_ADDR32.  */
12588     case EM_CYGNUS_FRV:
12589       return reloc_type == 1;
12590     case EM_CYGNUS_D10V:
12591     case EM_D10V:
12592       return reloc_type == 6; /* R_D10V_32.  */
12593     case EM_CYGNUS_D30V:
12594     case EM_D30V:
12595       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
12596     case EM_DLX:
12597       return reloc_type == 3; /* R_DLX_RELOC_32.  */
12598     case EM_CYGNUS_FR30:
12599     case EM_FR30:
12600       return reloc_type == 3; /* R_FR30_32.  */
12601     case EM_FT32:
12602       return reloc_type == 1; /* R_FT32_32.  */
12603     case EM_H8S:
12604     case EM_H8_300:
12605     case EM_H8_300H:
12606       return reloc_type == 1; /* R_H8_DIR32.  */
12607     case EM_IA_64:
12608       return (reloc_type == 0x64    /* R_IA64_SECREL32MSB.  */
12609               || reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
12610               || reloc_type == 0x24 /* R_IA64_DIR32MSB.  */
12611               || reloc_type == 0x25 /* R_IA64_DIR32LSB.  */);
12612     case EM_IP2K_OLD:
12613     case EM_IP2K:
12614       return reloc_type == 2; /* R_IP2K_32.  */
12615     case EM_IQ2000:
12616       return reloc_type == 2; /* R_IQ2000_32.  */
12617     case EM_LATTICEMICO32:
12618       return reloc_type == 3; /* R_LM32_32.  */
12619     case EM_M32C_OLD:
12620     case EM_M32C:
12621       return reloc_type == 3; /* R_M32C_32.  */
12622     case EM_M32R:
12623       return reloc_type == 34; /* R_M32R_32_RELA.  */
12624     case EM_68HC11:
12625     case EM_68HC12:
12626       return reloc_type == 6; /* R_M68HC11_32.  */
12627     case EM_S12Z:
12628       return reloc_type == 7 || /* R_S12Z_EXT32 */
12629         reloc_type == 6;        /* R_S12Z_CW32.  */
12630     case EM_MCORE:
12631       return reloc_type == 1; /* R_MCORE_ADDR32.  */
12632     case EM_CYGNUS_MEP:
12633       return reloc_type == 4; /* R_MEP_32.  */
12634     case EM_METAG:
12635       return reloc_type == 2; /* R_METAG_ADDR32.  */
12636     case EM_MICROBLAZE:
12637       return reloc_type == 1; /* R_MICROBLAZE_32.  */
12638     case EM_MIPS:
12639       return reloc_type == 2; /* R_MIPS_32.  */
12640     case EM_MMIX:
12641       return reloc_type == 4; /* R_MMIX_32.  */
12642     case EM_CYGNUS_MN10200:
12643     case EM_MN10200:
12644       return reloc_type == 1; /* R_MN10200_32.  */
12645     case EM_CYGNUS_MN10300:
12646     case EM_MN10300:
12647       return reloc_type == 1; /* R_MN10300_32.  */
12648     case EM_MOXIE:
12649       return reloc_type == 1; /* R_MOXIE_32.  */
12650     case EM_MSP430_OLD:
12651     case EM_MSP430:
12652       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
12653     case EM_MT:
12654       return reloc_type == 2; /* R_MT_32.  */
12655     case EM_NDS32:
12656       return reloc_type == 20; /* R_NDS32_RELA.  */
12657     case EM_ALTERA_NIOS2:
12658       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
12659     case EM_NIOS32:
12660       return reloc_type == 1; /* R_NIOS_32.  */
12661     case EM_OR1K:
12662       return reloc_type == 1; /* R_OR1K_32.  */
12663     case EM_PARISC:
12664       return (reloc_type == 1 /* R_PARISC_DIR32.  */
12665               || reloc_type == 2 /* R_PARISC_DIR21L.  */
12666               || reloc_type == 41); /* R_PARISC_SECREL32.  */
12667     case EM_PJ:
12668     case EM_PJ_OLD:
12669       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
12670     case EM_PPC64:
12671       return reloc_type == 1; /* R_PPC64_ADDR32.  */
12672     case EM_PPC:
12673       return reloc_type == 1; /* R_PPC_ADDR32.  */
12674     case EM_TI_PRU:
12675       return reloc_type == 11; /* R_PRU_BFD_RELOC_32.  */
12676     case EM_RISCV:
12677       return reloc_type == 1; /* R_RISCV_32.  */
12678     case EM_RL78:
12679       return reloc_type == 1; /* R_RL78_DIR32.  */
12680     case EM_RX:
12681       return reloc_type == 1; /* R_RX_DIR32.  */
12682     case EM_S370:
12683       return reloc_type == 1; /* R_I370_ADDR31.  */
12684     case EM_S390_OLD:
12685     case EM_S390:
12686       return reloc_type == 4; /* R_S390_32.  */
12687     case EM_SCORE:
12688       return reloc_type == 8; /* R_SCORE_ABS32.  */
12689     case EM_SH:
12690       return reloc_type == 1; /* R_SH_DIR32.  */
12691     case EM_SPARC32PLUS:
12692     case EM_SPARCV9:
12693     case EM_SPARC:
12694       return reloc_type == 3 /* R_SPARC_32.  */
12695         || reloc_type == 23; /* R_SPARC_UA32.  */
12696     case EM_SPU:
12697       return reloc_type == 6; /* R_SPU_ADDR32 */
12698     case EM_TI_C6000:
12699       return reloc_type == 1; /* R_C6000_ABS32.  */
12700     case EM_TILEGX:
12701       return reloc_type == 2; /* R_TILEGX_32.  */
12702     case EM_TILEPRO:
12703       return reloc_type == 1; /* R_TILEPRO_32.  */
12704     case EM_CYGNUS_V850:
12705     case EM_V850:
12706       return reloc_type == 6; /* R_V850_ABS32.  */
12707     case EM_V800:
12708       return reloc_type == 0x33; /* R_V810_WORD.  */
12709     case EM_VAX:
12710       return reloc_type == 1; /* R_VAX_32.  */
12711     case EM_VISIUM:
12712       return reloc_type == 3;  /* R_VISIUM_32. */
12713     case EM_WEBASSEMBLY:
12714       return reloc_type == 1;  /* R_WASM32_32.  */
12715     case EM_X86_64:
12716     case EM_L1OM:
12717     case EM_K1OM:
12718       return reloc_type == 10; /* R_X86_64_32.  */
12719     case EM_XC16X:
12720     case EM_C166:
12721       return reloc_type == 3; /* R_XC16C_ABS_32.  */
12722     case EM_XGATE:
12723       return reloc_type == 4; /* R_XGATE_32.  */
12724     case EM_XSTORMY16:
12725       return reloc_type == 1; /* R_XSTROMY16_32.  */
12726     case EM_XTENSA_OLD:
12727     case EM_XTENSA:
12728       return reloc_type == 1; /* R_XTENSA_32.  */
12729     default:
12730       {
12731         static unsigned int prev_warn = 0;
12732
12733         /* Avoid repeating the same warning multiple times.  */
12734         if (prev_warn != filedata->file_header.e_machine)
12735           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12736                  filedata->file_header.e_machine);
12737         prev_warn = filedata->file_header.e_machine;
12738         return FALSE;
12739       }
12740     }
12741 }
12742
12743 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12744    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
12745
12746 static bfd_boolean
12747 is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12748 {
12749   switch (filedata->file_header.e_machine)
12750   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12751     {
12752     case EM_386:
12753     case EM_IAMCU:
12754       return reloc_type == 2;  /* R_386_PC32.  */
12755     case EM_68K:
12756       return reloc_type == 4;  /* R_68K_PC32.  */
12757     case EM_AARCH64:
12758       return reloc_type == 261; /* R_AARCH64_PREL32 */
12759     case EM_ADAPTEVA_EPIPHANY:
12760       return reloc_type == 6;
12761     case EM_ALPHA:
12762       return reloc_type == 10; /* R_ALPHA_SREL32.  */
12763     case EM_ARC_COMPACT:
12764     case EM_ARC_COMPACT2:
12765       return reloc_type == 49; /* R_ARC_32_PCREL.  */
12766     case EM_ARM:
12767       return reloc_type == 3;  /* R_ARM_REL32 */
12768     case EM_AVR_OLD:
12769     case EM_AVR:
12770       return reloc_type == 36; /* R_AVR_32_PCREL.  */
12771     case EM_MICROBLAZE:
12772       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
12773     case EM_OR1K:
12774       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
12775     case EM_PARISC:
12776       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
12777     case EM_PPC:
12778       return reloc_type == 26; /* R_PPC_REL32.  */
12779     case EM_PPC64:
12780       return reloc_type == 26; /* R_PPC64_REL32.  */
12781     case EM_RISCV:
12782       return reloc_type == 57;  /* R_RISCV_32_PCREL.  */
12783     case EM_S390_OLD:
12784     case EM_S390:
12785       return reloc_type == 5;  /* R_390_PC32.  */
12786     case EM_SH:
12787       return reloc_type == 2;  /* R_SH_REL32.  */
12788     case EM_SPARC32PLUS:
12789     case EM_SPARCV9:
12790     case EM_SPARC:
12791       return reloc_type == 6;  /* R_SPARC_DISP32.  */
12792     case EM_SPU:
12793       return reloc_type == 13; /* R_SPU_REL32.  */
12794     case EM_TILEGX:
12795       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
12796     case EM_TILEPRO:
12797       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
12798     case EM_VISIUM:
12799       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
12800     case EM_X86_64:
12801     case EM_L1OM:
12802     case EM_K1OM:
12803       return reloc_type == 2;  /* R_X86_64_PC32.  */
12804     case EM_VAX:
12805       return reloc_type == 4;  /* R_VAX_PCREL32.  */
12806     case EM_XTENSA_OLD:
12807     case EM_XTENSA:
12808       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
12809     default:
12810       /* Do not abort or issue an error message here.  Not all targets use
12811          pc-relative 32-bit relocs in their DWARF debug information and we
12812          have already tested for target coverage in is_32bit_abs_reloc.  A
12813          more helpful warning message will be generated by apply_relocations
12814          anyway, so just return.  */
12815       return FALSE;
12816     }
12817 }
12818
12819 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12820    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
12821
12822 static bfd_boolean
12823 is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12824 {
12825   switch (filedata->file_header.e_machine)
12826     {
12827     case EM_AARCH64:
12828       return reloc_type == 257; /* R_AARCH64_ABS64.  */
12829     case EM_ALPHA:
12830       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
12831     case EM_IA_64:
12832       return (reloc_type == 0x26    /* R_IA64_DIR64MSB.  */
12833               || reloc_type == 0x27 /* R_IA64_DIR64LSB.  */);
12834     case EM_PARISC:
12835       return reloc_type == 80; /* R_PARISC_DIR64.  */
12836     case EM_PPC64:
12837       return reloc_type == 38; /* R_PPC64_ADDR64.  */
12838     case EM_RISCV:
12839       return reloc_type == 2; /* R_RISCV_64.  */
12840     case EM_SPARC32PLUS:
12841     case EM_SPARCV9:
12842     case EM_SPARC:
12843       return reloc_type == 32 /* R_SPARC_64.  */
12844         || reloc_type == 54; /* R_SPARC_UA64.  */
12845     case EM_X86_64:
12846     case EM_L1OM:
12847     case EM_K1OM:
12848       return reloc_type == 1; /* R_X86_64_64.  */
12849     case EM_S390_OLD:
12850     case EM_S390:
12851       return reloc_type == 22;  /* R_S390_64.  */
12852     case EM_TILEGX:
12853       return reloc_type == 1; /* R_TILEGX_64.  */
12854     case EM_MIPS:
12855       return reloc_type == 18;  /* R_MIPS_64.  */
12856     default:
12857       return FALSE;
12858     }
12859 }
12860
12861 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12862    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
12863
12864 static bfd_boolean
12865 is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12866 {
12867   switch (filedata->file_header.e_machine)
12868     {
12869     case EM_AARCH64:
12870       return reloc_type == 260; /* R_AARCH64_PREL64.  */
12871     case EM_ALPHA:
12872       return reloc_type == 11; /* R_ALPHA_SREL64.  */
12873     case EM_IA_64:
12874       return (reloc_type == 0x4e    /* R_IA64_PCREL64MSB.  */
12875               || reloc_type == 0x4f /* R_IA64_PCREL64LSB.  */);
12876     case EM_PARISC:
12877       return reloc_type == 72; /* R_PARISC_PCREL64.  */
12878     case EM_PPC64:
12879       return reloc_type == 44; /* R_PPC64_REL64.  */
12880     case EM_SPARC32PLUS:
12881     case EM_SPARCV9:
12882     case EM_SPARC:
12883       return reloc_type == 46; /* R_SPARC_DISP64.  */
12884     case EM_X86_64:
12885     case EM_L1OM:
12886     case EM_K1OM:
12887       return reloc_type == 24; /* R_X86_64_PC64.  */
12888     case EM_S390_OLD:
12889     case EM_S390:
12890       return reloc_type == 23;  /* R_S390_PC64.  */
12891     case EM_TILEGX:
12892       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
12893     default:
12894       return FALSE;
12895     }
12896 }
12897
12898 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12899    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
12900
12901 static bfd_boolean
12902 is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12903 {
12904   switch (filedata->file_header.e_machine)
12905     {
12906     case EM_CYGNUS_MN10200:
12907     case EM_MN10200:
12908       return reloc_type == 4; /* R_MN10200_24.  */
12909     case EM_FT32:
12910       return reloc_type == 5; /* R_FT32_20.  */
12911     default:
12912       return FALSE;
12913     }
12914 }
12915
12916 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12917    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
12918
12919 static bfd_boolean
12920 is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12921 {
12922   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12923   switch (filedata->file_header.e_machine)
12924     {
12925     case EM_ARC:
12926     case EM_ARC_COMPACT:
12927     case EM_ARC_COMPACT2:
12928       return reloc_type == 2; /* R_ARC_16.  */
12929     case EM_ADAPTEVA_EPIPHANY:
12930       return reloc_type == 5;
12931     case EM_AVR_OLD:
12932     case EM_AVR:
12933       return reloc_type == 4; /* R_AVR_16.  */
12934     case EM_CYGNUS_D10V:
12935     case EM_D10V:
12936       return reloc_type == 3; /* R_D10V_16.  */
12937     case EM_FT32:
12938       return reloc_type == 2; /* R_FT32_16.  */
12939     case EM_H8S:
12940     case EM_H8_300:
12941     case EM_H8_300H:
12942       return reloc_type == R_H8_DIR16;
12943     case EM_IP2K_OLD:
12944     case EM_IP2K:
12945       return reloc_type == 1; /* R_IP2K_16.  */
12946     case EM_M32C_OLD:
12947     case EM_M32C:
12948       return reloc_type == 1; /* R_M32C_16 */
12949     case EM_CYGNUS_MN10200:
12950     case EM_MN10200:
12951       return reloc_type == 2; /* R_MN10200_16.  */
12952     case EM_CYGNUS_MN10300:
12953     case EM_MN10300:
12954       return reloc_type == 2; /* R_MN10300_16.  */
12955     case EM_MSP430:
12956       if (uses_msp430x_relocs (filedata))
12957         return reloc_type == 2; /* R_MSP430_ABS16.  */
12958       /* Fall through.  */
12959     case EM_MSP430_OLD:
12960       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
12961     case EM_NDS32:
12962       return reloc_type == 19; /* R_NDS32_RELA.  */
12963     case EM_ALTERA_NIOS2:
12964       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
12965     case EM_NIOS32:
12966       return reloc_type == 9; /* R_NIOS_16.  */
12967     case EM_OR1K:
12968       return reloc_type == 2; /* R_OR1K_16.  */
12969     case EM_RISCV:
12970       return reloc_type == 55; /* R_RISCV_SET16.  */
12971     case EM_TI_PRU:
12972       return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
12973     case EM_TI_C6000:
12974       return reloc_type == 2; /* R_C6000_ABS16.  */
12975     case EM_VISIUM:
12976       return reloc_type == 2; /* R_VISIUM_16. */
12977     case EM_XC16X:
12978     case EM_C166:
12979       return reloc_type == 2; /* R_XC16C_ABS_16.  */
12980     case EM_XGATE:
12981       return reloc_type == 3; /* R_XGATE_16.  */
12982     default:
12983       return FALSE;
12984     }
12985 }
12986
12987 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12988    a 8-bit absolute RELA relocation used in DWARF debug sections.  */
12989
12990 static bfd_boolean
12991 is_8bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12992 {
12993   switch (filedata->file_header.e_machine)
12994     {
12995     case EM_RISCV:
12996       return reloc_type == 54; /* R_RISCV_SET8.  */
12997     default:
12998       return FALSE;
12999     }
13000 }
13001
13002 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13003    a 6-bit absolute RELA relocation used in DWARF debug sections.  */
13004
13005 static bfd_boolean
13006 is_6bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
13007 {
13008   switch (filedata->file_header.e_machine)
13009     {
13010     case EM_RISCV:
13011       return reloc_type == 53; /* R_RISCV_SET6.  */
13012     default:
13013       return FALSE;
13014     }
13015 }
13016
13017 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13018    a 32-bit inplace add RELA relocation used in DWARF debug sections.  */
13019
13020 static bfd_boolean
13021 is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13022 {
13023   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13024   switch (filedata->file_header.e_machine)
13025     {
13026     case EM_RISCV:
13027       return reloc_type == 35; /* R_RISCV_ADD32.  */
13028     default:
13029       return FALSE;
13030     }
13031 }
13032
13033 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13034    a 32-bit inplace sub RELA relocation used in DWARF debug sections.  */
13035
13036 static bfd_boolean
13037 is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13038 {
13039   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13040   switch (filedata->file_header.e_machine)
13041     {
13042     case EM_RISCV:
13043       return reloc_type == 39; /* R_RISCV_SUB32.  */
13044     default:
13045       return FALSE;
13046     }
13047 }
13048
13049 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13050    a 64-bit inplace add RELA relocation used in DWARF debug sections.  */
13051
13052 static bfd_boolean
13053 is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13054 {
13055   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13056   switch (filedata->file_header.e_machine)
13057     {
13058     case EM_RISCV:
13059       return reloc_type == 36; /* R_RISCV_ADD64.  */
13060     default:
13061       return FALSE;
13062     }
13063 }
13064
13065 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13066    a 64-bit inplace sub RELA relocation used in DWARF debug sections.  */
13067
13068 static bfd_boolean
13069 is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13070 {
13071   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13072   switch (filedata->file_header.e_machine)
13073     {
13074     case EM_RISCV:
13075       return reloc_type == 40; /* R_RISCV_SUB64.  */
13076     default:
13077       return FALSE;
13078     }
13079 }
13080
13081 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13082    a 16-bit inplace add RELA relocation used in DWARF debug sections.  */
13083
13084 static bfd_boolean
13085 is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13086 {
13087   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13088   switch (filedata->file_header.e_machine)
13089     {
13090     case EM_RISCV:
13091       return reloc_type == 34; /* R_RISCV_ADD16.  */
13092     default:
13093       return FALSE;
13094     }
13095 }
13096
13097 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13098    a 16-bit inplace sub RELA relocation used in DWARF debug sections.  */
13099
13100 static bfd_boolean
13101 is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13102 {
13103   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13104   switch (filedata->file_header.e_machine)
13105     {
13106     case EM_RISCV:
13107       return reloc_type == 38; /* R_RISCV_SUB16.  */
13108     default:
13109       return FALSE;
13110     }
13111 }
13112
13113 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13114    a 8-bit inplace add RELA relocation used in DWARF debug sections.  */
13115
13116 static bfd_boolean
13117 is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13118 {
13119   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13120   switch (filedata->file_header.e_machine)
13121     {
13122     case EM_RISCV:
13123       return reloc_type == 33; /* R_RISCV_ADD8.  */
13124     default:
13125       return FALSE;
13126     }
13127 }
13128
13129 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13130    a 8-bit inplace sub RELA relocation used in DWARF debug sections.  */
13131
13132 static bfd_boolean
13133 is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13134 {
13135   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13136   switch (filedata->file_header.e_machine)
13137     {
13138     case EM_RISCV:
13139       return reloc_type == 37; /* R_RISCV_SUB8.  */
13140     default:
13141       return FALSE;
13142     }
13143 }
13144
13145 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13146    a 6-bit inplace sub RELA relocation used in DWARF debug sections.  */
13147
13148 static bfd_boolean
13149 is_6bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13150 {
13151   switch (filedata->file_header.e_machine)
13152     {
13153     case EM_RISCV:
13154       return reloc_type == 52; /* R_RISCV_SUB6.  */
13155     default:
13156       return FALSE;
13157     }
13158 }
13159
13160 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13161    relocation entries (possibly formerly used for SHT_GROUP sections).  */
13162
13163 static bfd_boolean
13164 is_none_reloc (Filedata * filedata, unsigned int reloc_type)
13165 {
13166   switch (filedata->file_header.e_machine)
13167     {
13168     case EM_386:     /* R_386_NONE.  */
13169     case EM_68K:     /* R_68K_NONE.  */
13170     case EM_ADAPTEVA_EPIPHANY:
13171     case EM_ALPHA:   /* R_ALPHA_NONE.  */
13172     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
13173     case EM_ARC:     /* R_ARC_NONE.  */
13174     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
13175     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
13176     case EM_ARM:     /* R_ARM_NONE.  */
13177     case EM_C166:    /* R_XC16X_NONE.  */
13178     case EM_CRIS:    /* R_CRIS_NONE.  */
13179     case EM_FT32:    /* R_FT32_NONE.  */
13180     case EM_IA_64:   /* R_IA64_NONE.  */
13181     case EM_K1OM:    /* R_X86_64_NONE.  */
13182     case EM_L1OM:    /* R_X86_64_NONE.  */
13183     case EM_M32R:    /* R_M32R_NONE.  */
13184     case EM_MIPS:    /* R_MIPS_NONE.  */
13185     case EM_MN10300: /* R_MN10300_NONE.  */
13186     case EM_MOXIE:   /* R_MOXIE_NONE.  */
13187     case EM_NIOS32:  /* R_NIOS_NONE.  */
13188     case EM_OR1K:    /* R_OR1K_NONE. */
13189     case EM_PARISC:  /* R_PARISC_NONE.  */
13190     case EM_PPC64:   /* R_PPC64_NONE.  */
13191     case EM_PPC:     /* R_PPC_NONE.  */
13192     case EM_RISCV:   /* R_RISCV_NONE.  */
13193     case EM_S390:    /* R_390_NONE.  */
13194     case EM_S390_OLD:
13195     case EM_SH:      /* R_SH_NONE.  */
13196     case EM_SPARC32PLUS:
13197     case EM_SPARC:   /* R_SPARC_NONE.  */
13198     case EM_SPARCV9:
13199     case EM_TILEGX:  /* R_TILEGX_NONE.  */
13200     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
13201     case EM_TI_C6000:/* R_C6000_NONE.  */
13202     case EM_X86_64:  /* R_X86_64_NONE.  */
13203     case EM_XC16X:
13204     case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
13205       return reloc_type == 0;
13206
13207     case EM_AARCH64:
13208       return reloc_type == 0 || reloc_type == 256;
13209     case EM_AVR_OLD:
13210     case EM_AVR:
13211       return (reloc_type == 0 /* R_AVR_NONE.  */
13212               || reloc_type == 30 /* R_AVR_DIFF8.  */
13213               || reloc_type == 31 /* R_AVR_DIFF16.  */
13214               || reloc_type == 32 /* R_AVR_DIFF32.  */);
13215     case EM_METAG:
13216       return reloc_type == 3; /* R_METAG_NONE.  */
13217     case EM_NDS32:
13218       return (reloc_type == 0       /* R_XTENSA_NONE.  */
13219               || reloc_type == 204  /* R_NDS32_DIFF8.  */
13220               || reloc_type == 205  /* R_NDS32_DIFF16.  */
13221               || reloc_type == 206  /* R_NDS32_DIFF32.  */
13222               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
13223     case EM_TI_PRU:
13224       return (reloc_type == 0       /* R_PRU_NONE.  */
13225               || reloc_type == 65   /* R_PRU_DIFF8.  */
13226               || reloc_type == 66   /* R_PRU_DIFF16.  */
13227               || reloc_type == 67   /* R_PRU_DIFF32.  */);
13228     case EM_XTENSA_OLD:
13229     case EM_XTENSA:
13230       return (reloc_type == 0      /* R_XTENSA_NONE.  */
13231               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
13232               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
13233               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
13234     }
13235   return FALSE;
13236 }
13237
13238 /* Returns TRUE if there is a relocation against
13239    section NAME at OFFSET bytes.  */
13240
13241 bfd_boolean
13242 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
13243 {
13244   Elf_Internal_Rela * relocs;
13245   Elf_Internal_Rela * rp;
13246
13247   if (dsec == NULL || dsec->reloc_info == NULL)
13248     return FALSE;
13249
13250   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
13251
13252   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
13253     if (rp->r_offset == offset)
13254       return TRUE;
13255
13256    return FALSE;
13257 }
13258
13259 /* Apply relocations to a section.
13260    Returns TRUE upon success, FALSE otherwise.
13261    If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13262    It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
13263    will be set to the number of relocs loaded.
13264
13265    Note: So far support has been added only for those relocations
13266    which can be found in debug sections. FIXME: Add support for
13267    more relocations ?  */
13268
13269 static bfd_boolean
13270 apply_relocations (Filedata *                 filedata,
13271                    const Elf_Internal_Shdr *  section,
13272                    unsigned char *            start,
13273                    bfd_size_type              size,
13274                    void **                    relocs_return,
13275                    unsigned long *            num_relocs_return)
13276 {
13277   Elf_Internal_Shdr * relsec;
13278   unsigned char * end = start + size;
13279
13280   if (relocs_return != NULL)
13281     {
13282       * (Elf_Internal_Rela **) relocs_return = NULL;
13283       * num_relocs_return = 0;
13284     }
13285
13286   if (filedata->file_header.e_type != ET_REL)
13287     /* No relocs to apply.  */
13288     return TRUE;
13289
13290   /* Find the reloc section associated with the section.  */
13291   for (relsec = filedata->section_headers;
13292        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13293        ++relsec)
13294     {
13295       bfd_boolean is_rela;
13296       unsigned long num_relocs;
13297       Elf_Internal_Rela * relocs;
13298       Elf_Internal_Rela * rp;
13299       Elf_Internal_Shdr * symsec;
13300       Elf_Internal_Sym * symtab;
13301       unsigned long num_syms;
13302       Elf_Internal_Sym * sym;
13303
13304       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13305           || relsec->sh_info >= filedata->file_header.e_shnum
13306           || filedata->section_headers + relsec->sh_info != section
13307           || relsec->sh_size == 0
13308           || relsec->sh_link >= filedata->file_header.e_shnum)
13309         continue;
13310
13311       is_rela = relsec->sh_type == SHT_RELA;
13312
13313       if (is_rela)
13314         {
13315           if (!slurp_rela_relocs (filedata, relsec->sh_offset,
13316                                   relsec->sh_size, & relocs, & num_relocs))
13317             return FALSE;
13318         }
13319       else
13320         {
13321           if (!slurp_rel_relocs (filedata, relsec->sh_offset,
13322                                  relsec->sh_size, & relocs, & num_relocs))
13323             return FALSE;
13324         }
13325
13326       /* SH uses RELA but uses in place value instead of the addend field.  */
13327       if (filedata->file_header.e_machine == EM_SH)
13328         is_rela = FALSE;
13329
13330       symsec = filedata->section_headers + relsec->sh_link;
13331       if (symsec->sh_type != SHT_SYMTAB
13332           && symsec->sh_type != SHT_DYNSYM)
13333         return FALSE;
13334       symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
13335
13336       for (rp = relocs; rp < relocs + num_relocs; ++rp)
13337         {
13338           bfd_vma         addend;
13339           unsigned int    reloc_type;
13340           unsigned int    reloc_size;
13341           bfd_boolean     reloc_inplace = FALSE;
13342           bfd_boolean     reloc_subtract = FALSE;
13343           unsigned char * rloc;
13344           unsigned long   sym_index;
13345
13346           reloc_type = get_reloc_type (filedata, rp->r_info);
13347
13348           if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
13349             continue;
13350           else if (is_none_reloc (filedata, reloc_type))
13351             continue;
13352           else if (is_32bit_abs_reloc (filedata, reloc_type)
13353                    || is_32bit_pcrel_reloc (filedata, reloc_type))
13354             reloc_size = 4;
13355           else if (is_64bit_abs_reloc (filedata, reloc_type)
13356                    || is_64bit_pcrel_reloc (filedata, reloc_type))
13357             reloc_size = 8;
13358           else if (is_24bit_abs_reloc (filedata, reloc_type))
13359             reloc_size = 3;
13360           else if (is_16bit_abs_reloc (filedata, reloc_type))
13361             reloc_size = 2;
13362           else if (is_8bit_abs_reloc (filedata, reloc_type)
13363                    || is_6bit_abs_reloc (filedata, reloc_type))
13364             reloc_size = 1;
13365           else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
13366                                                                  reloc_type))
13367                    || is_32bit_inplace_add_reloc (filedata, reloc_type))
13368             {
13369               reloc_size = 4;
13370               reloc_inplace = TRUE;
13371             }
13372           else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
13373                                                                  reloc_type))
13374                    || is_64bit_inplace_add_reloc (filedata, reloc_type))
13375             {
13376               reloc_size = 8;
13377               reloc_inplace = TRUE;
13378             }
13379           else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
13380                                                                  reloc_type))
13381                    || is_16bit_inplace_add_reloc (filedata, reloc_type))
13382             {
13383               reloc_size = 2;
13384               reloc_inplace = TRUE;
13385             }
13386           else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
13387                                                                 reloc_type))
13388                    || is_8bit_inplace_add_reloc (filedata, reloc_type))
13389             {
13390               reloc_size = 1;
13391               reloc_inplace = TRUE;
13392             }
13393           else if ((reloc_subtract = is_6bit_inplace_sub_reloc (filedata,
13394                                                                 reloc_type)))
13395             {
13396               reloc_size = 1;
13397               reloc_inplace = TRUE;
13398             }
13399           else
13400             {
13401               static unsigned int prev_reloc = 0;
13402
13403               if (reloc_type != prev_reloc)
13404                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13405                       reloc_type, printable_section_name (filedata, section));
13406               prev_reloc = reloc_type;
13407               continue;
13408             }
13409
13410           rloc = start + rp->r_offset;
13411           if (rloc >= end || (rloc + reloc_size) > end || (rloc < start))
13412             {
13413               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13414                     (unsigned long) rp->r_offset,
13415                     printable_section_name (filedata, section));
13416               continue;
13417             }
13418
13419           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
13420           if (sym_index >= num_syms)
13421             {
13422               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13423                     sym_index, printable_section_name (filedata, section));
13424               continue;
13425             }
13426           sym = symtab + sym_index;
13427
13428           /* If the reloc has a symbol associated with it,
13429              make sure that it is of an appropriate type.
13430
13431              Relocations against symbols without type can happen.
13432              Gcc -feliminate-dwarf2-dups may generate symbols
13433              without type for debug info.
13434
13435              Icc generates relocations against function symbols
13436              instead of local labels.
13437
13438              Relocations against object symbols can happen, eg when
13439              referencing a global array.  For an example of this see
13440              the _clz.o binary in libgcc.a.  */
13441           if (sym != symtab
13442               && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13443               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13444             {
13445               warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13446                     get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13447                     printable_section_name (filedata, relsec),
13448                     (long int)(rp - relocs));
13449               continue;
13450             }
13451
13452           addend = 0;
13453           if (is_rela)
13454             addend += rp->r_addend;
13455           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13456              partial_inplace.  */
13457           if (!is_rela
13458               || (filedata->file_header.e_machine == EM_XTENSA
13459                   && reloc_type == 1)
13460               || ((filedata->file_header.e_machine == EM_PJ
13461                    || filedata->file_header.e_machine == EM_PJ_OLD)
13462                   && reloc_type == 1)
13463               || ((filedata->file_header.e_machine == EM_D30V
13464                    || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13465                   && reloc_type == 12)
13466               || reloc_inplace)
13467             {
13468               if (is_6bit_inplace_sub_reloc (filedata, reloc_type))
13469                 addend += byte_get (rloc, reloc_size) & 0x3f;
13470               else
13471                 addend += byte_get (rloc, reloc_size);
13472             }
13473
13474           if (is_32bit_pcrel_reloc (filedata, reloc_type)
13475               || is_64bit_pcrel_reloc (filedata, reloc_type))
13476             {
13477               /* On HPPA, all pc-relative relocations are biased by 8.  */
13478               if (filedata->file_header.e_machine == EM_PARISC)
13479                 addend -= 8;
13480               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13481                         reloc_size);
13482             }
13483           else if (is_6bit_abs_reloc (filedata, reloc_type)
13484                    || is_6bit_inplace_sub_reloc (filedata, reloc_type))
13485             {
13486               if (reloc_subtract)
13487                 addend -= sym->st_value;
13488               else
13489                 addend += sym->st_value;
13490               addend = (addend & 0x3f) | (byte_get (rloc, reloc_size) & 0xc0);
13491               byte_put (rloc, addend, reloc_size);
13492             }
13493           else if (reloc_subtract)
13494             byte_put (rloc, addend - sym->st_value, reloc_size);
13495           else
13496             byte_put (rloc, addend + sym->st_value, reloc_size);
13497         }
13498
13499       free (symtab);
13500       /* Let the target specific reloc processing code know that
13501          we have finished with these relocs.  */
13502       target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13503
13504       if (relocs_return)
13505         {
13506           * (Elf_Internal_Rela **) relocs_return = relocs;
13507           * num_relocs_return = num_relocs;
13508         }
13509       else
13510         free (relocs);
13511
13512       break;
13513     }
13514
13515   return TRUE;
13516 }
13517
13518 #ifdef SUPPORT_DISASSEMBLY
13519 static bfd_boolean
13520 disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13521 {
13522   printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13523
13524   /* FIXME: XXX -- to be done --- XXX */
13525
13526   return TRUE;
13527 }
13528 #endif
13529
13530 /* Reads in the contents of SECTION from FILE, returning a pointer
13531    to a malloc'ed buffer or NULL if something went wrong.  */
13532
13533 static char *
13534 get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13535 {
13536   bfd_size_type num_bytes = section->sh_size;
13537
13538   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13539     {
13540       printf (_("Section '%s' has no data to dump.\n"),
13541               printable_section_name (filedata, section));
13542       return NULL;
13543     }
13544
13545   return  (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13546                              _("section contents"));
13547 }
13548
13549 /* Uncompresses a section that was compressed using zlib, in place.  */
13550
13551 static bfd_boolean
13552 uncompress_section_contents (unsigned char **   buffer,
13553                              dwarf_size_type    uncompressed_size,
13554                              dwarf_size_type *  size)
13555 {
13556   dwarf_size_type compressed_size = *size;
13557   unsigned char * compressed_buffer = *buffer;
13558   unsigned char * uncompressed_buffer;
13559   z_stream strm;
13560   int rc;
13561
13562   /* It is possible the section consists of several compressed
13563      buffers concatenated together, so we uncompress in a loop.  */
13564   /* PR 18313: The state field in the z_stream structure is supposed
13565      to be invisible to the user (ie us), but some compilers will
13566      still complain about it being used without initialisation.  So
13567      we first zero the entire z_stream structure and then set the fields
13568      that we need.  */
13569   memset (& strm, 0, sizeof strm);
13570   strm.avail_in = compressed_size;
13571   strm.next_in = (Bytef *) compressed_buffer;
13572   strm.avail_out = uncompressed_size;
13573   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13574
13575   rc = inflateInit (& strm);
13576   while (strm.avail_in > 0)
13577     {
13578       if (rc != Z_OK)
13579         goto fail;
13580       strm.next_out = ((Bytef *) uncompressed_buffer
13581                        + (uncompressed_size - strm.avail_out));
13582       rc = inflate (&strm, Z_FINISH);
13583       if (rc != Z_STREAM_END)
13584         goto fail;
13585       rc = inflateReset (& strm);
13586     }
13587   rc = inflateEnd (& strm);
13588   if (rc != Z_OK
13589       || strm.avail_out != 0)
13590     goto fail;
13591
13592   *buffer = uncompressed_buffer;
13593   *size = uncompressed_size;
13594   return TRUE;
13595
13596  fail:
13597   free (uncompressed_buffer);
13598   /* Indicate decompression failure.  */
13599   *buffer = NULL;
13600   return FALSE;
13601 }
13602
13603 static bfd_boolean
13604 dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13605 {
13606   Elf_Internal_Shdr *  relsec;
13607   bfd_size_type        num_bytes;
13608   unsigned char *      data;
13609   unsigned char *      end;
13610   unsigned char *      real_start;
13611   unsigned char *      start;
13612   bfd_boolean          some_strings_shown;
13613
13614   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13615   if (start == NULL)
13616     /* PR 21820: Do not fail if the section was empty.  */
13617     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13618
13619   num_bytes = section->sh_size;
13620
13621   printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13622
13623   if (decompress_dumps)
13624     {
13625       dwarf_size_type new_size = num_bytes;
13626       dwarf_size_type uncompressed_size = 0;
13627
13628       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13629         {
13630           Elf_Internal_Chdr chdr;
13631           unsigned int compression_header_size
13632             = get_compression_header (& chdr, (unsigned char *) start,
13633                                       num_bytes);
13634
13635           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13636             {
13637               warn (_("section '%s' has unsupported compress type: %d\n"),
13638                     printable_section_name (filedata, section), chdr.ch_type);
13639               return FALSE;
13640             }
13641           uncompressed_size = chdr.ch_size;
13642           start += compression_header_size;
13643           new_size -= compression_header_size;
13644         }
13645       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13646         {
13647           /* Read the zlib header.  In this case, it should be "ZLIB"
13648              followed by the uncompressed section size, 8 bytes in
13649              big-endian order.  */
13650           uncompressed_size = start[4]; uncompressed_size <<= 8;
13651           uncompressed_size += start[5]; uncompressed_size <<= 8;
13652           uncompressed_size += start[6]; uncompressed_size <<= 8;
13653           uncompressed_size += start[7]; uncompressed_size <<= 8;
13654           uncompressed_size += start[8]; uncompressed_size <<= 8;
13655           uncompressed_size += start[9]; uncompressed_size <<= 8;
13656           uncompressed_size += start[10]; uncompressed_size <<= 8;
13657           uncompressed_size += start[11];
13658           start += 12;
13659           new_size -= 12;
13660         }
13661
13662       if (uncompressed_size)
13663         {
13664           if (uncompress_section_contents (& start,
13665                                            uncompressed_size, & new_size))
13666             num_bytes = new_size;
13667           else
13668             {
13669               error (_("Unable to decompress section %s\n"),
13670                      printable_section_name (filedata, section));
13671               return FALSE;
13672             }
13673         }
13674       else
13675         start = real_start;
13676     }
13677
13678   /* If the section being dumped has relocations against it the user might
13679      be expecting these relocations to have been applied.  Check for this
13680      case and issue a warning message in order to avoid confusion.
13681      FIXME: Maybe we ought to have an option that dumps a section with
13682      relocs applied ?  */
13683   for (relsec = filedata->section_headers;
13684        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13685        ++relsec)
13686     {
13687       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13688           || relsec->sh_info >= filedata->file_header.e_shnum
13689           || filedata->section_headers + relsec->sh_info != section
13690           || relsec->sh_size == 0
13691           || relsec->sh_link >= filedata->file_header.e_shnum)
13692         continue;
13693
13694       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13695       break;
13696     }
13697
13698   data = start;
13699   end  = start + num_bytes;
13700   some_strings_shown = FALSE;
13701
13702   while (data < end)
13703     {
13704       while (!ISPRINT (* data))
13705         if (++ data >= end)
13706           break;
13707
13708       if (data < end)
13709         {
13710           size_t maxlen = end - data;
13711
13712 #ifndef __MSVCRT__
13713           /* PR 11128: Use two separate invocations in order to work
13714              around bugs in the Solaris 8 implementation of printf.  */
13715           printf ("  [%6tx]  ", data - start);
13716 #else
13717           printf ("  [%6Ix]  ", (size_t) (data - start));
13718 #endif
13719           if (maxlen > 0)
13720             {
13721               print_symbol ((int) maxlen, (const char *) data);
13722               putchar ('\n');
13723               data += strnlen ((const char *) data, maxlen);
13724             }
13725           else
13726             {
13727               printf (_("<corrupt>\n"));
13728               data = end;
13729             }
13730           some_strings_shown = TRUE;
13731         }
13732     }
13733
13734   if (! some_strings_shown)
13735     printf (_("  No strings found in this section."));
13736
13737   free (real_start);
13738
13739   putchar ('\n');
13740   return TRUE;
13741 }
13742
13743 static bfd_boolean
13744 dump_section_as_bytes (Elf_Internal_Shdr *  section,
13745                        Filedata *           filedata,
13746                        bfd_boolean          relocate)
13747 {
13748   Elf_Internal_Shdr * relsec;
13749   bfd_size_type       bytes;
13750   bfd_size_type       section_size;
13751   bfd_vma             addr;
13752   unsigned char *     data;
13753   unsigned char *     real_start;
13754   unsigned char *     start;
13755
13756   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13757   if (start == NULL)
13758     /* PR 21820: Do not fail if the section was empty.  */
13759     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13760
13761   section_size = section->sh_size;
13762
13763   printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13764
13765   if (decompress_dumps)
13766     {
13767       dwarf_size_type new_size = section_size;
13768       dwarf_size_type uncompressed_size = 0;
13769
13770       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13771         {
13772           Elf_Internal_Chdr chdr;
13773           unsigned int compression_header_size
13774             = get_compression_header (& chdr, start, section_size);
13775
13776           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13777             {
13778               warn (_("section '%s' has unsupported compress type: %d\n"),
13779                     printable_section_name (filedata, section), chdr.ch_type);
13780               return FALSE;
13781             }
13782           uncompressed_size = chdr.ch_size;
13783           start += compression_header_size;
13784           new_size -= compression_header_size;
13785         }
13786       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13787         {
13788           /* Read the zlib header.  In this case, it should be "ZLIB"
13789              followed by the uncompressed section size, 8 bytes in
13790              big-endian order.  */
13791           uncompressed_size = start[4]; uncompressed_size <<= 8;
13792           uncompressed_size += start[5]; uncompressed_size <<= 8;
13793           uncompressed_size += start[6]; uncompressed_size <<= 8;
13794           uncompressed_size += start[7]; uncompressed_size <<= 8;
13795           uncompressed_size += start[8]; uncompressed_size <<= 8;
13796           uncompressed_size += start[9]; uncompressed_size <<= 8;
13797           uncompressed_size += start[10]; uncompressed_size <<= 8;
13798           uncompressed_size += start[11];
13799           start += 12;
13800           new_size -= 12;
13801         }
13802
13803       if (uncompressed_size)
13804         {
13805           if (uncompress_section_contents (& start, uncompressed_size,
13806                                            & new_size))
13807             {
13808               section_size = new_size;
13809             }
13810           else
13811             {
13812               error (_("Unable to decompress section %s\n"),
13813                      printable_section_name (filedata, section));
13814               /* FIXME: Print the section anyway ?  */
13815               return FALSE;
13816             }
13817         }
13818       else
13819         start = real_start;
13820     }
13821
13822   if (relocate)
13823     {
13824       if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
13825         return FALSE;
13826     }
13827   else
13828     {
13829       /* If the section being dumped has relocations against it the user might
13830          be expecting these relocations to have been applied.  Check for this
13831          case and issue a warning message in order to avoid confusion.
13832          FIXME: Maybe we ought to have an option that dumps a section with
13833          relocs applied ?  */
13834       for (relsec = filedata->section_headers;
13835            relsec < filedata->section_headers + filedata->file_header.e_shnum;
13836            ++relsec)
13837         {
13838           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13839               || relsec->sh_info >= filedata->file_header.e_shnum
13840               || filedata->section_headers + relsec->sh_info != section
13841               || relsec->sh_size == 0
13842               || relsec->sh_link >= filedata->file_header.e_shnum)
13843             continue;
13844
13845           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13846           break;
13847         }
13848     }
13849
13850   addr = section->sh_addr;
13851   bytes = section_size;
13852   data = start;
13853
13854   while (bytes)
13855     {
13856       int j;
13857       int k;
13858       int lbytes;
13859
13860       lbytes = (bytes > 16 ? 16 : bytes);
13861
13862       printf ("  0x%8.8lx ", (unsigned long) addr);
13863
13864       for (j = 0; j < 16; j++)
13865         {
13866           if (j < lbytes)
13867             printf ("%2.2x", data[j]);
13868           else
13869             printf ("  ");
13870
13871           if ((j & 3) == 3)
13872             printf (" ");
13873         }
13874
13875       for (j = 0; j < lbytes; j++)
13876         {
13877           k = data[j];
13878           if (k >= ' ' && k < 0x7f)
13879             printf ("%c", k);
13880           else
13881             printf (".");
13882         }
13883
13884       putchar ('\n');
13885
13886       data  += lbytes;
13887       addr  += lbytes;
13888       bytes -= lbytes;
13889     }
13890
13891   free (real_start);
13892
13893   putchar ('\n');
13894   return TRUE;
13895 }
13896
13897 static ctf_sect_t *
13898 shdr_to_ctf_sect (ctf_sect_t *buf, Elf_Internal_Shdr *shdr, Filedata *filedata)
13899 {
13900   buf->cts_name = SECTION_NAME (shdr);
13901   buf->cts_size = shdr->sh_size;
13902   buf->cts_entsize = shdr->sh_entsize;
13903
13904   return buf;
13905 }
13906
13907 /* Formatting callback function passed to ctf_dump.  Returns either the pointer
13908    it is passed, or a pointer to newly-allocated storage, in which case
13909    dump_ctf() will free it when it no longer needs it.  */
13910
13911 static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED,
13912                                     char *s, void *arg)
13913 {
13914   const char *blanks = arg;
13915   char *new_s;
13916
13917   if (asprintf (&new_s, "%s%s", blanks, s) < 0)
13918     return s;
13919   return new_s;
13920 }
13921
13922 static bfd_boolean
13923 dump_section_as_ctf (Elf_Internal_Shdr * section, Filedata * filedata)
13924 {
13925   Elf_Internal_Shdr *  parent_sec = NULL;
13926   Elf_Internal_Shdr *  symtab_sec = NULL;
13927   Elf_Internal_Shdr *  strtab_sec = NULL;
13928   void *               data = NULL;
13929   void *               symdata = NULL;
13930   void *               strdata = NULL;
13931   void *               parentdata = NULL;
13932   ctf_sect_t           ctfsect, symsect, strsect, parentsect;
13933   ctf_sect_t *         symsectp = NULL;
13934   ctf_sect_t *         strsectp = NULL;
13935   ctf_file_t *         ctf = NULL;
13936   ctf_file_t *         parent = NULL;
13937
13938   const char *things[] = {"Labels", "Data objects", "Function objects",
13939                           "Variables", "Types", "Strings", ""};
13940   const char **thing;
13941   int err;
13942   bfd_boolean ret = FALSE;
13943   size_t i;
13944
13945   shdr_to_ctf_sect (&ctfsect, section, filedata);
13946   data = get_section_contents (section, filedata);
13947   ctfsect.cts_data = data;
13948
13949   if (dump_ctf_symtab_name)
13950     {
13951       if ((symtab_sec = find_section (filedata, dump_ctf_symtab_name)) == NULL)
13952         {
13953           error (_("No symbol section named %s\n"), dump_ctf_symtab_name);
13954           goto fail;
13955         }
13956       if ((symdata = (void *) get_data (NULL, filedata,
13957                                         symtab_sec->sh_offset, 1,
13958                                         symtab_sec->sh_size,
13959                                         _("symbols"))) == NULL)
13960         goto fail;
13961       symsectp = shdr_to_ctf_sect (&symsect, symtab_sec, filedata);
13962       symsect.cts_data = symdata;
13963     }
13964   if (dump_ctf_strtab_name)
13965     {
13966       if ((strtab_sec = find_section (filedata, dump_ctf_strtab_name)) == NULL)
13967         {
13968           error (_("No string table section named %s\n"),
13969                  dump_ctf_strtab_name);
13970           goto fail;
13971         }
13972       if ((strdata = (void *) get_data (NULL, filedata,
13973                                         strtab_sec->sh_offset, 1,
13974                                         strtab_sec->sh_size,
13975                                         _("strings"))) == NULL)
13976         goto fail;
13977       strsectp = shdr_to_ctf_sect (&strsect, strtab_sec, filedata);
13978       strsect.cts_data = strdata;
13979     }
13980   if (dump_ctf_parent_name)
13981     {
13982       if ((parent_sec = find_section (filedata, dump_ctf_parent_name)) == NULL)
13983         {
13984           error (_("No CTF parent section named %s\n"), dump_ctf_parent_name);
13985           goto fail;
13986         }
13987       if ((parentdata = (void *) get_data (NULL, filedata,
13988                                            parent_sec->sh_offset, 1,
13989                                            parent_sec->sh_size,
13990                                            _("CTF parent"))) == NULL)
13991         goto fail;
13992       shdr_to_ctf_sect (&parentsect, parent_sec, filedata);
13993       parentsect.cts_data = parentdata;
13994     }
13995
13996   /* Load the CTF file and dump it.  */
13997
13998   if ((ctf = ctf_bufopen (&ctfsect, symsectp, strsectp, &err)) == NULL)
13999     {
14000       error (_("CTF open failure: %s\n"), ctf_errmsg (err));
14001       goto fail;
14002     }
14003
14004   if (parentdata)
14005     {
14006       if ((parent = ctf_bufopen (&parentsect, symsectp, strsectp, &err)) == NULL)
14007         {
14008           error (_("CTF open failure: %s\n"), ctf_errmsg (err));
14009           goto fail;
14010         }
14011
14012       ctf_import (ctf, parent);
14013     }
14014
14015   ret = TRUE;
14016
14017   printf (_("\nDump of CTF section '%s':\n"),
14018           printable_section_name (filedata, section));
14019
14020   for (i = 1, thing = things; *thing[0]; thing++, i++)
14021     {
14022       ctf_dump_state_t *s = NULL;
14023       char *item;
14024
14025       printf ("\n  %s:\n", *thing);
14026       while ((item = ctf_dump (ctf, &s, i, dump_ctf_indent_lines,
14027                                (void *) "    ")) != NULL)
14028         {
14029           printf ("%s\n", item);
14030           free (item);
14031         }
14032
14033       if (ctf_errno (ctf))
14034         {
14035           error (_("Iteration failed: %s, %s\n"), *thing,
14036                    ctf_errmsg (ctf_errno (ctf)));
14037           ret = FALSE;
14038         }
14039     }
14040
14041  fail:
14042   ctf_file_close (ctf);
14043   ctf_file_close (parent);
14044   free (parentdata);
14045   free (data);
14046   free (symdata);
14047   free (strdata);
14048   return ret;
14049 }
14050
14051 static bfd_boolean
14052 load_specific_debug_section (enum dwarf_section_display_enum  debug,
14053                              const Elf_Internal_Shdr *        sec,
14054                              void *                           data)
14055 {
14056   struct dwarf_section * section = &debug_displays [debug].section;
14057   char buf [64];
14058   Filedata * filedata = (Filedata *) data;
14059
14060   if (section->start != NULL)
14061     {
14062       /* If it is already loaded, do nothing.  */
14063       if (streq (section->filename, filedata->file_name))
14064         return TRUE;
14065       free (section->start);
14066     }
14067
14068   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
14069   section->address = sec->sh_addr;
14070   section->user_data = NULL;
14071   section->filename = filedata->file_name;
14072   section->start = (unsigned char *) get_data (NULL, filedata,
14073                                                sec->sh_offset, 1,
14074                                                sec->sh_size, buf);
14075   if (section->start == NULL)
14076     section->size = 0;
14077   else
14078     {
14079       unsigned char *start = section->start;
14080       dwarf_size_type size = sec->sh_size;
14081       dwarf_size_type uncompressed_size = 0;
14082
14083       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
14084         {
14085           Elf_Internal_Chdr chdr;
14086           unsigned int compression_header_size;
14087
14088           if (size < (is_32bit_elf
14089                       ? sizeof (Elf32_External_Chdr)
14090                       : sizeof (Elf64_External_Chdr)))
14091             {
14092               warn (_("compressed section %s is too small to contain a compression header"),
14093                     section->name);
14094               return FALSE;
14095             }
14096
14097           compression_header_size = get_compression_header (&chdr, start, size);
14098
14099           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
14100             {
14101               warn (_("section '%s' has unsupported compress type: %d\n"),
14102                     section->name, chdr.ch_type);
14103               return FALSE;
14104             }
14105           uncompressed_size = chdr.ch_size;
14106           start += compression_header_size;
14107           size -= compression_header_size;
14108         }
14109       else if (size > 12 && streq ((char *) start, "ZLIB"))
14110         {
14111           /* Read the zlib header.  In this case, it should be "ZLIB"
14112              followed by the uncompressed section size, 8 bytes in
14113              big-endian order.  */
14114           uncompressed_size = start[4]; uncompressed_size <<= 8;
14115           uncompressed_size += start[5]; uncompressed_size <<= 8;
14116           uncompressed_size += start[6]; uncompressed_size <<= 8;
14117           uncompressed_size += start[7]; uncompressed_size <<= 8;
14118           uncompressed_size += start[8]; uncompressed_size <<= 8;
14119           uncompressed_size += start[9]; uncompressed_size <<= 8;
14120           uncompressed_size += start[10]; uncompressed_size <<= 8;
14121           uncompressed_size += start[11];
14122           start += 12;
14123           size -= 12;
14124         }
14125
14126       if (uncompressed_size)
14127         {
14128           if (uncompress_section_contents (&start, uncompressed_size,
14129                                            &size))
14130             {
14131               /* Free the compressed buffer, update the section buffer
14132                  and the section size if uncompress is successful.  */
14133               free (section->start);
14134               section->start = start;
14135             }
14136           else
14137             {
14138               error (_("Unable to decompress section %s\n"),
14139                      printable_section_name (filedata, sec));
14140               return FALSE;
14141             }
14142         }
14143
14144       section->size = size;
14145     }
14146
14147   if (section->start == NULL)
14148     return FALSE;
14149
14150   if (debug_displays [debug].relocate)
14151     {
14152       if (! apply_relocations (filedata, sec, section->start, section->size,
14153                                & section->reloc_info, & section->num_relocs))
14154         return FALSE;
14155     }
14156   else
14157     {
14158       section->reloc_info = NULL;
14159       section->num_relocs = 0;
14160     }
14161
14162   return TRUE;
14163 }
14164
14165 /* If this is not NULL, load_debug_section will only look for sections
14166    within the list of sections given here.  */
14167 static unsigned int * section_subset = NULL;
14168
14169 bfd_boolean
14170 load_debug_section (enum dwarf_section_display_enum debug, void * data)
14171 {
14172   struct dwarf_section * section = &debug_displays [debug].section;
14173   Elf_Internal_Shdr * sec;
14174   Filedata * filedata = (Filedata *) data;
14175
14176   /* Without section headers we cannot find any sections.  */
14177   if (filedata->section_headers == NULL)
14178     return FALSE;
14179
14180   if (filedata->string_table == NULL
14181       && filedata->file_header.e_shstrndx != SHN_UNDEF
14182       && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
14183     {
14184       Elf_Internal_Shdr * strs;
14185
14186       /* Read in the string table, so that we have section names to scan.  */
14187       strs = filedata->section_headers + filedata->file_header.e_shstrndx;
14188
14189       if (strs != NULL && strs->sh_size != 0)
14190         {
14191           filedata->string_table
14192             = (char *) get_data (NULL, filedata, strs->sh_offset,
14193                                  1, strs->sh_size, _("string table"));
14194
14195           filedata->string_table_length
14196             = filedata->string_table != NULL ? strs->sh_size : 0;
14197         }
14198     }
14199
14200   /* Locate the debug section.  */
14201   sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
14202   if (sec != NULL)
14203     section->name = section->uncompressed_name;
14204   else
14205     {
14206       sec = find_section_in_set (filedata, section->compressed_name, section_subset);
14207       if (sec != NULL)
14208         section->name = section->compressed_name;
14209     }
14210   if (sec == NULL)
14211     return FALSE;
14212
14213   /* If we're loading from a subset of sections, and we've loaded
14214      a section matching this name before, it's likely that it's a
14215      different one.  */
14216   if (section_subset != NULL)
14217     free_debug_section (debug);
14218
14219   return load_specific_debug_section (debug, sec, data);
14220 }
14221
14222 void
14223 free_debug_section (enum dwarf_section_display_enum debug)
14224 {
14225   struct dwarf_section * section = &debug_displays [debug].section;
14226
14227   if (section->start == NULL)
14228     return;
14229
14230   free ((char *) section->start);
14231   section->start = NULL;
14232   section->address = 0;
14233   section->size = 0;
14234 }
14235
14236 static bfd_boolean
14237 display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
14238 {
14239   char * name = SECTION_NAME (section);
14240   const char * print_name = printable_section_name (filedata, section);
14241   bfd_size_type length;
14242   bfd_boolean result = TRUE;
14243   int i;
14244
14245   length = section->sh_size;
14246   if (length == 0)
14247     {
14248       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
14249       return TRUE;
14250     }
14251   if (section->sh_type == SHT_NOBITS)
14252     {
14253       /* There is no point in dumping the contents of a debugging section
14254          which has the NOBITS type - the bits in the file will be random.
14255          This can happen when a file containing a .eh_frame section is
14256          stripped with the --only-keep-debug command line option.  */
14257       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14258               print_name);
14259       return FALSE;
14260     }
14261
14262   if (const_strneq (name, ".gnu.linkonce.wi."))
14263     name = ".debug_info";
14264
14265   /* See if we know how to display the contents of this section.  */
14266   for (i = 0; i < max; i++)
14267     {
14268       enum dwarf_section_display_enum  id = (enum dwarf_section_display_enum) i;
14269       struct dwarf_section_display *   display = debug_displays + i;
14270       struct dwarf_section *           sec = & display->section;
14271
14272       if (streq (sec->uncompressed_name, name)
14273           || (id == line && const_strneq (name, ".debug_line."))
14274           || streq (sec->compressed_name, name))
14275         {
14276           bfd_boolean secondary = (section != find_section (filedata, name));
14277
14278           if (secondary)
14279             free_debug_section (id);
14280
14281           if (i == line && const_strneq (name, ".debug_line."))
14282             sec->name = name;
14283           else if (streq (sec->uncompressed_name, name))
14284             sec->name = sec->uncompressed_name;
14285           else
14286             sec->name = sec->compressed_name;
14287
14288           if (load_specific_debug_section (id, section, filedata))
14289             {
14290               /* If this debug section is part of a CU/TU set in a .dwp file,
14291                  restrict load_debug_section to the sections in that set.  */
14292               section_subset = find_cu_tu_set (filedata, shndx);
14293
14294               result &= display->display (sec, filedata);
14295
14296               section_subset = NULL;
14297
14298               if (secondary || (id != info && id != abbrev))
14299                 free_debug_section (id);
14300             }
14301           break;
14302         }
14303     }
14304
14305   if (i == max)
14306     {
14307       printf (_("Unrecognized debug section: %s\n"), print_name);
14308       result = FALSE;
14309     }
14310
14311   return result;
14312 }
14313
14314 /* Set DUMP_SECTS for all sections where dumps were requested
14315    based on section name.  */
14316
14317 static void
14318 initialise_dumps_byname (Filedata * filedata)
14319 {
14320   struct dump_list_entry * cur;
14321
14322   for (cur = dump_sects_byname; cur; cur = cur->next)
14323     {
14324       unsigned int i;
14325       bfd_boolean any = FALSE;
14326
14327       for (i = 0; i < filedata->file_header.e_shnum; i++)
14328         if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
14329           {
14330             request_dump_bynumber (filedata, i, cur->type);
14331             any = TRUE;
14332           }
14333
14334       if (!any)
14335         warn (_("Section '%s' was not dumped because it does not exist!\n"),
14336               cur->name);
14337     }
14338 }
14339
14340 static bfd_boolean
14341 process_section_contents (Filedata * filedata)
14342 {
14343   Elf_Internal_Shdr * section;
14344   unsigned int i;
14345   bfd_boolean res = TRUE;
14346
14347   if (! do_dump)
14348     return TRUE;
14349
14350   initialise_dumps_byname (filedata);
14351
14352   for (i = 0, section = filedata->section_headers;
14353        i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
14354        i++, section++)
14355     {
14356       dump_type dump = filedata->dump_sects[i];
14357
14358 #ifdef SUPPORT_DISASSEMBLY
14359       if (dump & DISASS_DUMP)
14360         {
14361           if (! disassemble_section (section, filedata))
14362             res = FALSE;
14363         }
14364 #endif
14365       if (dump & HEX_DUMP)
14366         {
14367           if (! dump_section_as_bytes (section, filedata, FALSE))
14368             res = FALSE;
14369         }
14370
14371       if (dump & RELOC_DUMP)
14372         {
14373           if (! dump_section_as_bytes (section, filedata, TRUE))
14374             res = FALSE;
14375         }
14376
14377       if (dump & STRING_DUMP)
14378         {
14379           if (! dump_section_as_strings (section, filedata))
14380             res = FALSE;
14381         }
14382
14383       if (dump & DEBUG_DUMP)
14384         {
14385           if (! display_debug_section (i, section, filedata))
14386             res = FALSE;
14387         }
14388
14389       if (dump & CTF_DUMP)
14390         {
14391           if (! dump_section_as_ctf (section, filedata))
14392             res = FALSE;
14393         }
14394     }
14395
14396   /* Check to see if the user requested a
14397      dump of a section that does not exist.  */
14398   while (i < filedata->num_dump_sects)
14399     {
14400       if (filedata->dump_sects[i])
14401         {
14402           warn (_("Section %d was not dumped because it does not exist!\n"), i);
14403           res = FALSE;
14404         }
14405       i++;
14406     }
14407
14408   return res;
14409 }
14410
14411 static void
14412 process_mips_fpe_exception (int mask)
14413 {
14414   if (mask)
14415     {
14416       bfd_boolean first = TRUE;
14417
14418       if (mask & OEX_FPU_INEX)
14419         fputs ("INEX", stdout), first = FALSE;
14420       if (mask & OEX_FPU_UFLO)
14421         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
14422       if (mask & OEX_FPU_OFLO)
14423         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
14424       if (mask & OEX_FPU_DIV0)
14425         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
14426       if (mask & OEX_FPU_INVAL)
14427         printf ("%sINVAL", first ? "" : "|");
14428     }
14429   else
14430     fputs ("0", stdout);
14431 }
14432
14433 /* Display's the value of TAG at location P.  If TAG is
14434    greater than 0 it is assumed to be an unknown tag, and
14435    a message is printed to this effect.  Otherwise it is
14436    assumed that a message has already been printed.
14437
14438    If the bottom bit of TAG is set it assumed to have a
14439    string value, otherwise it is assumed to have an integer
14440    value.
14441
14442    Returns an updated P pointing to the first unread byte
14443    beyond the end of TAG's value.
14444
14445    Reads at or beyond END will not be made.  */
14446
14447 static unsigned char *
14448 display_tag_value (signed int tag,
14449                    unsigned char * p,
14450                    const unsigned char * const end)
14451 {
14452   unsigned long val;
14453
14454   if (tag > 0)
14455     printf ("  Tag_unknown_%d: ", tag);
14456
14457   if (p >= end)
14458     {
14459       warn (_("<corrupt tag>\n"));
14460     }
14461   else if (tag & 1)
14462     {
14463       /* PR 17531 file: 027-19978-0.004.  */
14464       size_t maxlen = (end - p) - 1;
14465
14466       putchar ('"');
14467       if (maxlen > 0)
14468         {
14469           print_symbol ((int) maxlen, (const char *) p);
14470           p += strnlen ((char *) p, maxlen) + 1;
14471         }
14472       else
14473         {
14474           printf (_("<corrupt string tag>"));
14475           p = (unsigned char *) end;
14476         }
14477       printf ("\"\n");
14478     }
14479   else
14480     {
14481       unsigned int len;
14482
14483       val = read_uleb128 (p, &len, end);
14484       p += len;
14485       printf ("%ld (0x%lx)\n", val, val);
14486     }
14487
14488   assert (p <= end);
14489   return p;
14490 }
14491
14492 /* ARC ABI attributes section.  */
14493
14494 static unsigned char *
14495 display_arc_attribute (unsigned char * p,
14496                        const unsigned char * const end)
14497 {
14498   unsigned int tag;
14499   unsigned int len;
14500   unsigned int val;
14501
14502   tag = read_uleb128 (p, &len, end);
14503   p += len;
14504
14505   switch (tag)
14506     {
14507     case Tag_ARC_PCS_config:
14508       val = read_uleb128 (p, &len, end);
14509       p += len;
14510       printf ("  Tag_ARC_PCS_config: ");
14511       switch (val)
14512         {
14513         case 0:
14514           printf (_("Absent/Non standard\n"));
14515           break;
14516         case 1:
14517           printf (_("Bare metal/mwdt\n"));
14518           break;
14519         case 2:
14520           printf (_("Bare metal/newlib\n"));
14521           break;
14522         case 3:
14523           printf (_("Linux/uclibc\n"));
14524           break;
14525         case 4:
14526           printf (_("Linux/glibc\n"));
14527           break;
14528         default:
14529           printf (_("Unknown\n"));
14530           break;
14531         }
14532       break;
14533
14534     case Tag_ARC_CPU_base:
14535       val = read_uleb128 (p, &len, end);
14536       p += len;
14537       printf ("  Tag_ARC_CPU_base: ");
14538       switch (val)
14539         {
14540         default:
14541         case TAG_CPU_NONE:
14542           printf (_("Absent\n"));
14543           break;
14544         case TAG_CPU_ARC6xx:
14545           printf ("ARC6xx\n");
14546           break;
14547         case TAG_CPU_ARC7xx:
14548           printf ("ARC7xx\n");
14549           break;
14550         case TAG_CPU_ARCEM:
14551           printf ("ARCEM\n");
14552           break;
14553         case TAG_CPU_ARCHS:
14554           printf ("ARCHS\n");
14555           break;
14556         }
14557       break;
14558
14559     case Tag_ARC_CPU_variation:
14560       val = read_uleb128 (p, &len, end);
14561       p += len;
14562       printf ("  Tag_ARC_CPU_variation: ");
14563       switch (val)
14564         {
14565         default:
14566           if (val > 0 && val < 16)
14567               printf ("Core%d\n", val);
14568           else
14569               printf ("Unknown\n");
14570           break;
14571
14572         case 0:
14573           printf (_("Absent\n"));
14574           break;
14575         }
14576       break;
14577
14578     case Tag_ARC_CPU_name:
14579       printf ("  Tag_ARC_CPU_name: ");
14580       p = display_tag_value (-1, p, end);
14581       break;
14582
14583     case Tag_ARC_ABI_rf16:
14584       val = read_uleb128 (p, &len, end);
14585       p += len;
14586       printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
14587       break;
14588
14589     case Tag_ARC_ABI_osver:
14590       val = read_uleb128 (p, &len, end);
14591       p += len;
14592       printf ("  Tag_ARC_ABI_osver: v%d\n", val);
14593       break;
14594
14595     case Tag_ARC_ABI_pic:
14596     case Tag_ARC_ABI_sda:
14597       val = read_uleb128 (p, &len, end);
14598       p += len;
14599       printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
14600               : "  Tag_ARC_ABI_pic: ");
14601       switch (val)
14602         {
14603         case 0:
14604           printf (_("Absent\n"));
14605           break;
14606         case 1:
14607           printf ("MWDT\n");
14608           break;
14609         case 2:
14610           printf ("GNU\n");
14611           break;
14612         default:
14613           printf (_("Unknown\n"));
14614           break;
14615         }
14616       break;
14617
14618     case Tag_ARC_ABI_tls:
14619       val = read_uleb128 (p, &len, end);
14620       p += len;
14621       printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14622       break;
14623
14624     case Tag_ARC_ABI_enumsize:
14625       val = read_uleb128 (p, &len, end);
14626       p += len;
14627       printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14628               _("smallest"));
14629       break;
14630
14631     case Tag_ARC_ABI_exceptions:
14632       val = read_uleb128 (p, &len, end);
14633       p += len;
14634       printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14635               : _("default"));
14636       break;
14637
14638     case Tag_ARC_ABI_double_size:
14639       val = read_uleb128 (p, &len, end);
14640       p += len;
14641       printf ("  Tag_ARC_ABI_double_size: %d\n", val);
14642       break;
14643
14644     case Tag_ARC_ISA_config:
14645       printf ("  Tag_ARC_ISA_config: ");
14646       p = display_tag_value (-1, p, end);
14647       break;
14648
14649     case Tag_ARC_ISA_apex:
14650       printf ("  Tag_ARC_ISA_apex: ");
14651       p = display_tag_value (-1, p, end);
14652       break;
14653
14654     case Tag_ARC_ISA_mpy_option:
14655       val = read_uleb128 (p, &len, end);
14656       p += len;
14657       printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
14658       break;
14659
14660     case Tag_ARC_ATR_version:
14661       val = read_uleb128 (p, &len, end);
14662       p += len;
14663       printf ("  Tag_ARC_ATR_version: %d\n", val);
14664       break;
14665
14666     default:
14667       return display_tag_value (tag & 1, p, end);
14668     }
14669
14670   return p;
14671 }
14672
14673 /* ARM EABI attributes section.  */
14674 typedef struct
14675 {
14676   unsigned int tag;
14677   const char * name;
14678   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
14679   unsigned int type;
14680   const char ** table;
14681 } arm_attr_public_tag;
14682
14683 static const char * arm_attr_tag_CPU_arch[] =
14684   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14685    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14686    "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
14687 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14688 static const char * arm_attr_tag_THUMB_ISA_use[] =
14689   {"No", "Thumb-1", "Thumb-2", "Yes"};
14690 static const char * arm_attr_tag_FP_arch[] =
14691   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14692    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14693 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14694 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14695   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14696    "NEON for ARMv8.1"};
14697 static const char * arm_attr_tag_PCS_config[] =
14698   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14699    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14700 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14701   {"V6", "SB", "TLS", "Unused"};
14702 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14703   {"Absolute", "PC-relative", "SB-relative", "None"};
14704 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14705   {"Absolute", "PC-relative", "None"};
14706 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14707   {"None", "direct", "GOT-indirect"};
14708 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14709   {"None", "??? 1", "2", "??? 3", "4"};
14710 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14711 static const char * arm_attr_tag_ABI_FP_denormal[] =
14712   {"Unused", "Needed", "Sign only"};
14713 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14714 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14715 static const char * arm_attr_tag_ABI_FP_number_model[] =
14716   {"Unused", "Finite", "RTABI", "IEEE 754"};
14717 static const char * arm_attr_tag_ABI_enum_size[] =
14718   {"Unused", "small", "int", "forced to int"};
14719 static const char * arm_attr_tag_ABI_HardFP_use[] =
14720   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14721 static const char * arm_attr_tag_ABI_VFP_args[] =
14722   {"AAPCS", "VFP registers", "custom", "compatible"};
14723 static const char * arm_attr_tag_ABI_WMMX_args[] =
14724   {"AAPCS", "WMMX registers", "custom"};
14725 static const char * arm_attr_tag_ABI_optimization_goals[] =
14726   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14727     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14728 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14729   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14730     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14731 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14732 static const char * arm_attr_tag_FP_HP_extension[] =
14733   {"Not Allowed", "Allowed"};
14734 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14735   {"None", "IEEE 754", "Alternative Format"};
14736 static const char * arm_attr_tag_DSP_extension[] =
14737   {"Follow architecture", "Allowed"};
14738 static const char * arm_attr_tag_MPextension_use[] =
14739   {"Not Allowed", "Allowed"};
14740 static const char * arm_attr_tag_DIV_use[] =
14741   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14742     "Allowed in v7-A with integer division extension"};
14743 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14744 static const char * arm_attr_tag_Virtualization_use[] =
14745   {"Not Allowed", "TrustZone", "Virtualization Extensions",
14746     "TrustZone and Virtualization Extensions"};
14747 static const char * arm_attr_tag_MPextension_use_legacy[] =
14748   {"Not Allowed", "Allowed"};
14749
14750 static const char * arm_attr_tag_MVE_arch[] =
14751   {"No MVE", "MVE Integer only", "MVE Integer and FP"};
14752
14753 #define LOOKUP(id, name) \
14754   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14755 static arm_attr_public_tag arm_attr_public_tags[] =
14756 {
14757   {4, "CPU_raw_name", 1, NULL},
14758   {5, "CPU_name", 1, NULL},
14759   LOOKUP(6, CPU_arch),
14760   {7, "CPU_arch_profile", 0, NULL},
14761   LOOKUP(8, ARM_ISA_use),
14762   LOOKUP(9, THUMB_ISA_use),
14763   LOOKUP(10, FP_arch),
14764   LOOKUP(11, WMMX_arch),
14765   LOOKUP(12, Advanced_SIMD_arch),
14766   LOOKUP(13, PCS_config),
14767   LOOKUP(14, ABI_PCS_R9_use),
14768   LOOKUP(15, ABI_PCS_RW_data),
14769   LOOKUP(16, ABI_PCS_RO_data),
14770   LOOKUP(17, ABI_PCS_GOT_use),
14771   LOOKUP(18, ABI_PCS_wchar_t),
14772   LOOKUP(19, ABI_FP_rounding),
14773   LOOKUP(20, ABI_FP_denormal),
14774   LOOKUP(21, ABI_FP_exceptions),
14775   LOOKUP(22, ABI_FP_user_exceptions),
14776   LOOKUP(23, ABI_FP_number_model),
14777   {24, "ABI_align_needed", 0, NULL},
14778   {25, "ABI_align_preserved", 0, NULL},
14779   LOOKUP(26, ABI_enum_size),
14780   LOOKUP(27, ABI_HardFP_use),
14781   LOOKUP(28, ABI_VFP_args),
14782   LOOKUP(29, ABI_WMMX_args),
14783   LOOKUP(30, ABI_optimization_goals),
14784   LOOKUP(31, ABI_FP_optimization_goals),
14785   {32, "compatibility", 0, NULL},
14786   LOOKUP(34, CPU_unaligned_access),
14787   LOOKUP(36, FP_HP_extension),
14788   LOOKUP(38, ABI_FP_16bit_format),
14789   LOOKUP(42, MPextension_use),
14790   LOOKUP(44, DIV_use),
14791   LOOKUP(46, DSP_extension),
14792   LOOKUP(48, MVE_arch),
14793   {64, "nodefaults", 0, NULL},
14794   {65, "also_compatible_with", 0, NULL},
14795   LOOKUP(66, T2EE_use),
14796   {67, "conformance", 1, NULL},
14797   LOOKUP(68, Virtualization_use),
14798   LOOKUP(70, MPextension_use_legacy)
14799 };
14800 #undef LOOKUP
14801
14802 static unsigned char *
14803 display_arm_attribute (unsigned char * p,
14804                        const unsigned char * const end)
14805 {
14806   unsigned int tag;
14807   unsigned int len;
14808   unsigned int val;
14809   arm_attr_public_tag * attr;
14810   unsigned i;
14811   unsigned int type;
14812
14813   tag = read_uleb128 (p, &len, end);
14814   p += len;
14815   attr = NULL;
14816   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14817     {
14818       if (arm_attr_public_tags[i].tag == tag)
14819         {
14820           attr = &arm_attr_public_tags[i];
14821           break;
14822         }
14823     }
14824
14825   if (attr)
14826     {
14827       printf ("  Tag_%s: ", attr->name);
14828       switch (attr->type)
14829         {
14830         case 0:
14831           switch (tag)
14832             {
14833             case 7: /* Tag_CPU_arch_profile.  */
14834               val = read_uleb128 (p, &len, end);
14835               p += len;
14836               switch (val)
14837                 {
14838                 case 0: printf (_("None\n")); break;
14839                 case 'A': printf (_("Application\n")); break;
14840                 case 'R': printf (_("Realtime\n")); break;
14841                 case 'M': printf (_("Microcontroller\n")); break;
14842                 case 'S': printf (_("Application or Realtime\n")); break;
14843                 default: printf ("??? (%d)\n", val); break;
14844                 }
14845               break;
14846
14847             case 24: /* Tag_align_needed.  */
14848               val = read_uleb128 (p, &len, end);
14849               p += len;
14850               switch (val)
14851                 {
14852                 case 0: printf (_("None\n")); break;
14853                 case 1: printf (_("8-byte\n")); break;
14854                 case 2: printf (_("4-byte\n")); break;
14855                 case 3: printf ("??? 3\n"); break;
14856                 default:
14857                   if (val <= 12)
14858                     printf (_("8-byte and up to %d-byte extended\n"),
14859                             1 << val);
14860                   else
14861                     printf ("??? (%d)\n", val);
14862                   break;
14863                 }
14864               break;
14865
14866             case 25: /* Tag_align_preserved.  */
14867               val = read_uleb128 (p, &len, end);
14868               p += len;
14869               switch (val)
14870                 {
14871                 case 0: printf (_("None\n")); break;
14872                 case 1: printf (_("8-byte, except leaf SP\n")); break;
14873                 case 2: printf (_("8-byte\n")); break;
14874                 case 3: printf ("??? 3\n"); break;
14875                 default:
14876                   if (val <= 12)
14877                     printf (_("8-byte and up to %d-byte extended\n"),
14878                             1 << val);
14879                   else
14880                     printf ("??? (%d)\n", val);
14881                   break;
14882                 }
14883               break;
14884
14885             case 32: /* Tag_compatibility.  */
14886               {
14887                 val = read_uleb128 (p, &len, end);
14888                 p += len;
14889                 printf (_("flag = %d, vendor = "), val);
14890                 if (p < end - 1)
14891                   {
14892                     size_t maxlen = (end - p) - 1;
14893
14894                     print_symbol ((int) maxlen, (const char *) p);
14895                     p += strnlen ((char *) p, maxlen) + 1;
14896                   }
14897                 else
14898                   {
14899                     printf (_("<corrupt>"));
14900                     p = (unsigned char *) end;
14901                   }
14902                 putchar ('\n');
14903               }
14904               break;
14905
14906             case 64: /* Tag_nodefaults.  */
14907               /* PR 17531: file: 001-505008-0.01.  */
14908               if (p < end)
14909                 p++;
14910               printf (_("True\n"));
14911               break;
14912
14913             case 65: /* Tag_also_compatible_with.  */
14914               val = read_uleb128 (p, &len, end);
14915               p += len;
14916               if (val == 6 /* Tag_CPU_arch.  */)
14917                 {
14918                   val = read_uleb128 (p, &len, end);
14919                   p += len;
14920                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14921                     printf ("??? (%d)\n", val);
14922                   else
14923                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14924                 }
14925               else
14926                 printf ("???\n");
14927               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
14928                 ;
14929               break;
14930
14931             default:
14932               printf (_("<unknown: %d>\n"), tag);
14933               break;
14934             }
14935           return p;
14936
14937         case 1:
14938           return display_tag_value (-1, p, end);
14939         case 2:
14940           return display_tag_value (0, p, end);
14941
14942         default:
14943           assert (attr->type & 0x80);
14944           val = read_uleb128 (p, &len, end);
14945           p += len;
14946           type = attr->type & 0x7f;
14947           if (val >= type)
14948             printf ("??? (%d)\n", val);
14949           else
14950             printf ("%s\n", attr->table[val]);
14951           return p;
14952         }
14953     }
14954
14955   return display_tag_value (tag, p, end);
14956 }
14957
14958 static unsigned char *
14959 display_gnu_attribute (unsigned char * p,
14960                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14961                        const unsigned char * const end)
14962 {
14963   int tag;
14964   unsigned int len;
14965   unsigned int val;
14966
14967   tag = read_uleb128 (p, &len, end);
14968   p += len;
14969
14970   /* Tag_compatibility is the only generic GNU attribute defined at
14971      present.  */
14972   if (tag == 32)
14973     {
14974       val = read_uleb128 (p, &len, end);
14975       p += len;
14976
14977       printf (_("flag = %d, vendor = "), val);
14978       if (p == end)
14979         {
14980           printf (_("<corrupt>\n"));
14981           warn (_("corrupt vendor attribute\n"));
14982         }
14983       else
14984         {
14985           if (p < end - 1)
14986             {
14987               size_t maxlen = (end - p) - 1;
14988
14989               print_symbol ((int) maxlen, (const char *) p);
14990               p += strnlen ((char *) p, maxlen) + 1;
14991             }
14992           else
14993             {
14994               printf (_("<corrupt>"));
14995               p = (unsigned char *) end;
14996             }
14997           putchar ('\n');
14998         }
14999       return p;
15000     }
15001
15002   if ((tag & 2) == 0 && display_proc_gnu_attribute)
15003     return display_proc_gnu_attribute (p, tag, end);
15004
15005   return display_tag_value (tag, p, end);
15006 }
15007
15008 static unsigned char *
15009 display_power_gnu_attribute (unsigned char * p,
15010                              unsigned int tag,
15011                              const unsigned char * const end)
15012 {
15013   unsigned int len;
15014   unsigned int val;
15015
15016   if (tag == Tag_GNU_Power_ABI_FP)
15017     {
15018       val = read_uleb128 (p, &len, end);
15019       p += len;
15020       printf ("  Tag_GNU_Power_ABI_FP: ");
15021       if (len == 0)
15022         {
15023           printf (_("<corrupt>\n"));
15024           return p;
15025         }
15026
15027       if (val > 15)
15028         printf ("(%#x), ", val);
15029
15030       switch (val & 3)
15031         {
15032         case 0:
15033           printf (_("unspecified hard/soft float, "));
15034           break;
15035         case 1:
15036           printf (_("hard float, "));
15037           break;
15038         case 2:
15039           printf (_("soft float, "));
15040           break;
15041         case 3:
15042           printf (_("single-precision hard float, "));
15043           break;
15044         }
15045
15046       switch (val & 0xC)
15047         {
15048         case 0:
15049           printf (_("unspecified long double\n"));
15050           break;
15051         case 4:
15052           printf (_("128-bit IBM long double\n"));
15053           break;
15054         case 8:
15055           printf (_("64-bit long double\n"));
15056           break;
15057         case 12:
15058           printf (_("128-bit IEEE long double\n"));
15059           break;
15060         }
15061       return p;
15062     }
15063
15064   if (tag == Tag_GNU_Power_ABI_Vector)
15065     {
15066       val = read_uleb128 (p, &len, end);
15067       p += len;
15068       printf ("  Tag_GNU_Power_ABI_Vector: ");
15069       if (len == 0)
15070         {
15071           printf (_("<corrupt>\n"));
15072           return p;
15073         }
15074
15075       if (val > 3)
15076         printf ("(%#x), ", val);
15077
15078       switch (val & 3)
15079         {
15080         case 0:
15081           printf (_("unspecified\n"));
15082           break;
15083         case 1:
15084           printf (_("generic\n"));
15085           break;
15086         case 2:
15087           printf ("AltiVec\n");
15088           break;
15089         case 3:
15090           printf ("SPE\n");
15091           break;
15092         }
15093       return p;
15094     }
15095
15096   if (tag == Tag_GNU_Power_ABI_Struct_Return)
15097     {
15098       val = read_uleb128 (p, &len, end);
15099       p += len;
15100       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
15101       if (len == 0)
15102         {
15103           printf (_("<corrupt>\n"));
15104           return p;
15105         }
15106
15107       if (val > 2)
15108         printf ("(%#x), ", val);
15109
15110       switch (val & 3)
15111         {
15112         case 0:
15113           printf (_("unspecified\n"));
15114           break;
15115         case 1:
15116           printf ("r3/r4\n");
15117           break;
15118         case 2:
15119           printf (_("memory\n"));
15120           break;
15121         case 3:
15122           printf ("???\n");
15123           break;
15124         }
15125       return p;
15126     }
15127
15128   return display_tag_value (tag & 1, p, end);
15129 }
15130
15131 static unsigned char *
15132 display_s390_gnu_attribute (unsigned char * p,
15133                             unsigned int tag,
15134                             const unsigned char * const end)
15135 {
15136   unsigned int len;
15137   int val;
15138
15139   if (tag == Tag_GNU_S390_ABI_Vector)
15140     {
15141       val = read_uleb128 (p, &len, end);
15142       p += len;
15143       printf ("  Tag_GNU_S390_ABI_Vector: ");
15144
15145       switch (val)
15146         {
15147         case 0:
15148           printf (_("any\n"));
15149           break;
15150         case 1:
15151           printf (_("software\n"));
15152           break;
15153         case 2:
15154           printf (_("hardware\n"));
15155           break;
15156         default:
15157           printf ("??? (%d)\n", val);
15158           break;
15159         }
15160       return p;
15161    }
15162
15163   return display_tag_value (tag & 1, p, end);
15164 }
15165
15166 static void
15167 display_sparc_hwcaps (unsigned int mask)
15168 {
15169   if (mask)
15170     {
15171       bfd_boolean first = TRUE;
15172
15173       if (mask & ELF_SPARC_HWCAP_MUL32)
15174         fputs ("mul32", stdout), first = FALSE;
15175       if (mask & ELF_SPARC_HWCAP_DIV32)
15176         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
15177       if (mask & ELF_SPARC_HWCAP_FSMULD)
15178         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
15179       if (mask & ELF_SPARC_HWCAP_V8PLUS)
15180         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
15181       if (mask & ELF_SPARC_HWCAP_POPC)
15182         printf ("%spopc", first ? "" : "|"), first = FALSE;
15183       if (mask & ELF_SPARC_HWCAP_VIS)
15184         printf ("%svis", first ? "" : "|"), first = FALSE;
15185       if (mask & ELF_SPARC_HWCAP_VIS2)
15186         printf ("%svis2", first ? "" : "|"), first = FALSE;
15187       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
15188         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
15189       if (mask & ELF_SPARC_HWCAP_FMAF)
15190         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
15191       if (mask & ELF_SPARC_HWCAP_VIS3)
15192         printf ("%svis3", first ? "" : "|"), first = FALSE;
15193       if (mask & ELF_SPARC_HWCAP_HPC)
15194         printf ("%shpc", first ? "" : "|"), first = FALSE;
15195       if (mask & ELF_SPARC_HWCAP_RANDOM)
15196         printf ("%srandom", first ? "" : "|"), first = FALSE;
15197       if (mask & ELF_SPARC_HWCAP_TRANS)
15198         printf ("%strans", first ? "" : "|"), first = FALSE;
15199       if (mask & ELF_SPARC_HWCAP_FJFMAU)
15200         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
15201       if (mask & ELF_SPARC_HWCAP_IMA)
15202         printf ("%sima", first ? "" : "|"), first = FALSE;
15203       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
15204         printf ("%scspare", first ? "" : "|"), first = FALSE;
15205     }
15206   else
15207     fputc ('0', stdout);
15208   fputc ('\n', stdout);
15209 }
15210
15211 static void
15212 display_sparc_hwcaps2 (unsigned int mask)
15213 {
15214   if (mask)
15215     {
15216       bfd_boolean first = TRUE;
15217
15218       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
15219         fputs ("fjathplus", stdout), first = FALSE;
15220       if (mask & ELF_SPARC_HWCAP2_VIS3B)
15221         printf ("%svis3b", first ? "" : "|"), first = FALSE;
15222       if (mask & ELF_SPARC_HWCAP2_ADP)
15223         printf ("%sadp", first ? "" : "|"), first = FALSE;
15224       if (mask & ELF_SPARC_HWCAP2_SPARC5)
15225         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
15226       if (mask & ELF_SPARC_HWCAP2_MWAIT)
15227         printf ("%smwait", first ? "" : "|"), first = FALSE;
15228       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
15229         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
15230       if (mask & ELF_SPARC_HWCAP2_XMONT)
15231         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
15232       if (mask & ELF_SPARC_HWCAP2_NSEC)
15233         printf ("%snsec", first ? "" : "|"), first = FALSE;
15234       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
15235         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
15236       if (mask & ELF_SPARC_HWCAP2_FJDES)
15237         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
15238       if (mask & ELF_SPARC_HWCAP2_FJAES)
15239         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
15240     }
15241   else
15242     fputc ('0', stdout);
15243   fputc ('\n', stdout);
15244 }
15245
15246 static unsigned char *
15247 display_sparc_gnu_attribute (unsigned char * p,
15248                              unsigned int tag,
15249                              const unsigned char * const end)
15250 {
15251   unsigned int len;
15252   int val;
15253
15254   if (tag == Tag_GNU_Sparc_HWCAPS)
15255     {
15256       val = read_uleb128 (p, &len, end);
15257       p += len;
15258       printf ("  Tag_GNU_Sparc_HWCAPS: ");
15259       display_sparc_hwcaps (val);
15260       return p;
15261     }
15262   if (tag == Tag_GNU_Sparc_HWCAPS2)
15263     {
15264       val = read_uleb128 (p, &len, end);
15265       p += len;
15266       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
15267       display_sparc_hwcaps2 (val);
15268       return p;
15269     }
15270
15271   return display_tag_value (tag, p, end);
15272 }
15273
15274 static void
15275 print_mips_fp_abi_value (unsigned int val)
15276 {
15277   switch (val)
15278     {
15279     case Val_GNU_MIPS_ABI_FP_ANY:
15280       printf (_("Hard or soft float\n"));
15281       break;
15282     case Val_GNU_MIPS_ABI_FP_DOUBLE:
15283       printf (_("Hard float (double precision)\n"));
15284       break;
15285     case Val_GNU_MIPS_ABI_FP_SINGLE:
15286       printf (_("Hard float (single precision)\n"));
15287       break;
15288     case Val_GNU_MIPS_ABI_FP_SOFT:
15289       printf (_("Soft float\n"));
15290       break;
15291     case Val_GNU_MIPS_ABI_FP_OLD_64:
15292       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15293       break;
15294     case Val_GNU_MIPS_ABI_FP_XX:
15295       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15296       break;
15297     case Val_GNU_MIPS_ABI_FP_64:
15298       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15299       break;
15300     case Val_GNU_MIPS_ABI_FP_64A:
15301       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15302       break;
15303     case Val_GNU_MIPS_ABI_FP_NAN2008:
15304       printf (_("NaN 2008 compatibility\n"));
15305       break;
15306     default:
15307       printf ("??? (%d)\n", val);
15308       break;
15309     }
15310 }
15311
15312 static unsigned char *
15313 display_mips_gnu_attribute (unsigned char * p,
15314                             unsigned int tag,
15315                             const unsigned char * const end)
15316 {
15317   if (tag == Tag_GNU_MIPS_ABI_FP)
15318     {
15319       unsigned int len;
15320       unsigned int val;
15321
15322       val = read_uleb128 (p, &len, end);
15323       p += len;
15324       printf ("  Tag_GNU_MIPS_ABI_FP: ");
15325
15326       print_mips_fp_abi_value (val);
15327
15328       return p;
15329    }
15330
15331   if (tag == Tag_GNU_MIPS_ABI_MSA)
15332     {
15333       unsigned int len;
15334       unsigned int val;
15335
15336       val = read_uleb128 (p, &len, end);
15337       p += len;
15338       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
15339
15340       switch (val)
15341         {
15342         case Val_GNU_MIPS_ABI_MSA_ANY:
15343           printf (_("Any MSA or not\n"));
15344           break;
15345         case Val_GNU_MIPS_ABI_MSA_128:
15346           printf (_("128-bit MSA\n"));
15347           break;
15348         default:
15349           printf ("??? (%d)\n", val);
15350           break;
15351         }
15352       return p;
15353     }
15354
15355   return display_tag_value (tag & 1, p, end);
15356 }
15357
15358 static unsigned char *
15359 display_tic6x_attribute (unsigned char * p,
15360                          const unsigned char * const end)
15361 {
15362   unsigned int tag;
15363   unsigned int len;
15364   int val;
15365
15366   tag = read_uleb128 (p, &len, end);
15367   p += len;
15368
15369   switch (tag)
15370     {
15371     case Tag_ISA:
15372       val = read_uleb128 (p, &len, end);
15373       p += len;
15374       printf ("  Tag_ISA: ");
15375
15376       switch (val)
15377         {
15378         case C6XABI_Tag_ISA_none:
15379           printf (_("None\n"));
15380           break;
15381         case C6XABI_Tag_ISA_C62X:
15382           printf ("C62x\n");
15383           break;
15384         case C6XABI_Tag_ISA_C67X:
15385           printf ("C67x\n");
15386           break;
15387         case C6XABI_Tag_ISA_C67XP:
15388           printf ("C67x+\n");
15389           break;
15390         case C6XABI_Tag_ISA_C64X:
15391           printf ("C64x\n");
15392           break;
15393         case C6XABI_Tag_ISA_C64XP:
15394           printf ("C64x+\n");
15395           break;
15396         case C6XABI_Tag_ISA_C674X:
15397           printf ("C674x\n");
15398           break;
15399         default:
15400           printf ("??? (%d)\n", val);
15401           break;
15402         }
15403       return p;
15404
15405     case Tag_ABI_wchar_t:
15406       val = read_uleb128 (p, &len, end);
15407       p += len;
15408       printf ("  Tag_ABI_wchar_t: ");
15409       switch (val)
15410         {
15411         case 0:
15412           printf (_("Not used\n"));
15413           break;
15414         case 1:
15415           printf (_("2 bytes\n"));
15416           break;
15417         case 2:
15418           printf (_("4 bytes\n"));
15419           break;
15420         default:
15421           printf ("??? (%d)\n", val);
15422           break;
15423         }
15424       return p;
15425
15426     case Tag_ABI_stack_align_needed:
15427       val = read_uleb128 (p, &len, end);
15428       p += len;
15429       printf ("  Tag_ABI_stack_align_needed: ");
15430       switch (val)
15431         {
15432         case 0:
15433           printf (_("8-byte\n"));
15434           break;
15435         case 1:
15436           printf (_("16-byte\n"));
15437           break;
15438         default:
15439           printf ("??? (%d)\n", val);
15440           break;
15441         }
15442       return p;
15443
15444     case Tag_ABI_stack_align_preserved:
15445       val = read_uleb128 (p, &len, end);
15446       p += len;
15447       printf ("  Tag_ABI_stack_align_preserved: ");
15448       switch (val)
15449         {
15450         case 0:
15451           printf (_("8-byte\n"));
15452           break;
15453         case 1:
15454           printf (_("16-byte\n"));
15455           break;
15456         default:
15457           printf ("??? (%d)\n", val);
15458           break;
15459         }
15460       return p;
15461
15462     case Tag_ABI_DSBT:
15463       val = read_uleb128 (p, &len, end);
15464       p += len;
15465       printf ("  Tag_ABI_DSBT: ");
15466       switch (val)
15467         {
15468         case 0:
15469           printf (_("DSBT addressing not used\n"));
15470           break;
15471         case 1:
15472           printf (_("DSBT addressing used\n"));
15473           break;
15474         default:
15475           printf ("??? (%d)\n", val);
15476           break;
15477         }
15478       return p;
15479
15480     case Tag_ABI_PID:
15481       val = read_uleb128 (p, &len, end);
15482       p += len;
15483       printf ("  Tag_ABI_PID: ");
15484       switch (val)
15485         {
15486         case 0:
15487           printf (_("Data addressing position-dependent\n"));
15488           break;
15489         case 1:
15490           printf (_("Data addressing position-independent, GOT near DP\n"));
15491           break;
15492         case 2:
15493           printf (_("Data addressing position-independent, GOT far from DP\n"));
15494           break;
15495         default:
15496           printf ("??? (%d)\n", val);
15497           break;
15498         }
15499       return p;
15500
15501     case Tag_ABI_PIC:
15502       val = read_uleb128 (p, &len, end);
15503       p += len;
15504       printf ("  Tag_ABI_PIC: ");
15505       switch (val)
15506         {
15507         case 0:
15508           printf (_("Code addressing position-dependent\n"));
15509           break;
15510         case 1:
15511           printf (_("Code addressing position-independent\n"));
15512           break;
15513         default:
15514           printf ("??? (%d)\n", val);
15515           break;
15516         }
15517       return p;
15518
15519     case Tag_ABI_array_object_alignment:
15520       val = read_uleb128 (p, &len, end);
15521       p += len;
15522       printf ("  Tag_ABI_array_object_alignment: ");
15523       switch (val)
15524         {
15525         case 0:
15526           printf (_("8-byte\n"));
15527           break;
15528         case 1:
15529           printf (_("4-byte\n"));
15530           break;
15531         case 2:
15532           printf (_("16-byte\n"));
15533           break;
15534         default:
15535           printf ("??? (%d)\n", val);
15536           break;
15537         }
15538       return p;
15539
15540     case Tag_ABI_array_object_align_expected:
15541       val = read_uleb128 (p, &len, end);
15542       p += len;
15543       printf ("  Tag_ABI_array_object_align_expected: ");
15544       switch (val)
15545         {
15546         case 0:
15547           printf (_("8-byte\n"));
15548           break;
15549         case 1:
15550           printf (_("4-byte\n"));
15551           break;
15552         case 2:
15553           printf (_("16-byte\n"));
15554           break;
15555         default:
15556           printf ("??? (%d)\n", val);
15557           break;
15558         }
15559       return p;
15560
15561     case Tag_ABI_compatibility:
15562       {
15563         val = read_uleb128 (p, &len, end);
15564         p += len;
15565         printf ("  Tag_ABI_compatibility: ");
15566         printf (_("flag = %d, vendor = "), val);
15567         if (p < end - 1)
15568           {
15569             size_t maxlen = (end - p) - 1;
15570
15571             print_symbol ((int) maxlen, (const char *) p);
15572             p += strnlen ((char *) p, maxlen) + 1;
15573           }
15574         else
15575           {
15576             printf (_("<corrupt>"));
15577             p = (unsigned char *) end;
15578           }
15579         putchar ('\n');
15580         return p;
15581       }
15582
15583     case Tag_ABI_conformance:
15584       {
15585         printf ("  Tag_ABI_conformance: \"");
15586         if (p < end - 1)
15587           {
15588             size_t maxlen = (end - p) - 1;
15589
15590             print_symbol ((int) maxlen, (const char *) p);
15591             p += strnlen ((char *) p, maxlen) + 1;
15592           }
15593         else
15594           {
15595             printf (_("<corrupt>"));
15596             p = (unsigned char *) end;
15597           }
15598         printf ("\"\n");
15599         return p;
15600       }
15601     }
15602
15603   return display_tag_value (tag, p, end);
15604 }
15605
15606 static void
15607 display_raw_attribute (unsigned char * p, unsigned char const * const end)
15608 {
15609   unsigned long addr = 0;
15610   size_t bytes = end - p;
15611
15612   assert (end >= p);
15613   while (bytes)
15614     {
15615       int j;
15616       int k;
15617       int lbytes = (bytes > 16 ? 16 : bytes);
15618
15619       printf ("  0x%8.8lx ", addr);
15620
15621       for (j = 0; j < 16; j++)
15622         {
15623           if (j < lbytes)
15624             printf ("%2.2x", p[j]);
15625           else
15626             printf ("  ");
15627
15628           if ((j & 3) == 3)
15629             printf (" ");
15630         }
15631
15632       for (j = 0; j < lbytes; j++)
15633         {
15634           k = p[j];
15635           if (k >= ' ' && k < 0x7f)
15636             printf ("%c", k);
15637           else
15638             printf (".");
15639         }
15640
15641       putchar ('\n');
15642
15643       p  += lbytes;
15644       bytes -= lbytes;
15645       addr += lbytes;
15646     }
15647
15648   putchar ('\n');
15649 }
15650
15651 static unsigned char *
15652 display_msp430x_attribute (unsigned char * p,
15653                            const unsigned char * const end)
15654 {
15655   unsigned int len;
15656   unsigned int val;
15657   unsigned int tag;
15658
15659   tag = read_uleb128 (p, & len, end);
15660   p += len;
15661
15662   switch (tag)
15663     {
15664     case OFBA_MSPABI_Tag_ISA:
15665       val = read_uleb128 (p, &len, end);
15666       p += len;
15667       printf ("  Tag_ISA: ");
15668       switch (val)
15669         {
15670         case 0: printf (_("None\n")); break;
15671         case 1: printf (_("MSP430\n")); break;
15672         case 2: printf (_("MSP430X\n")); break;
15673         default: printf ("??? (%d)\n", val); break;
15674         }
15675       break;
15676
15677     case OFBA_MSPABI_Tag_Code_Model:
15678       val = read_uleb128 (p, &len, end);
15679       p += len;
15680       printf ("  Tag_Code_Model: ");
15681       switch (val)
15682         {
15683         case 0: printf (_("None\n")); break;
15684         case 1: printf (_("Small\n")); break;
15685         case 2: printf (_("Large\n")); break;
15686         default: printf ("??? (%d)\n", val); break;
15687         }
15688       break;
15689
15690     case OFBA_MSPABI_Tag_Data_Model:
15691       val = read_uleb128 (p, &len, end);
15692       p += len;
15693       printf ("  Tag_Data_Model: ");
15694       switch (val)
15695         {
15696         case 0: printf (_("None\n")); break;
15697         case 1: printf (_("Small\n")); break;
15698         case 2: printf (_("Large\n")); break;
15699         case 3: printf (_("Restricted Large\n")); break;
15700         default: printf ("??? (%d)\n", val); break;
15701         }
15702       break;
15703
15704     default:
15705       printf (_("  <unknown tag %d>: "), tag);
15706
15707       if (tag & 1)
15708         {
15709           putchar ('"');
15710           if (p < end - 1)
15711             {
15712               size_t maxlen = (end - p) - 1;
15713
15714               print_symbol ((int) maxlen, (const char *) p);
15715               p += strnlen ((char *) p, maxlen) + 1;
15716             }
15717           else
15718             {
15719               printf (_("<corrupt>"));
15720               p = (unsigned char *) end;
15721             }
15722           printf ("\"\n");
15723         }
15724       else
15725         {
15726           val = read_uleb128 (p, &len, end);
15727           p += len;
15728           printf ("%d (0x%x)\n", val, val);
15729         }
15730       break;
15731    }
15732
15733   assert (p <= end);
15734   return p;
15735 }
15736
15737 struct riscv_attr_tag_t {
15738   const char *name;
15739   int tag;
15740 };
15741
15742 static struct riscv_attr_tag_t riscv_attr_tag[] =
15743 {
15744 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
15745   T(arch),
15746   T(priv_spec),
15747   T(priv_spec_minor),
15748   T(priv_spec_revision),
15749   T(unaligned_access),
15750   T(stack_align),
15751 #undef T
15752 };
15753
15754 static unsigned char *
15755 display_riscv_attribute (unsigned char *p,
15756                          const unsigned char * const end)
15757 {
15758   unsigned int len;
15759   int val;
15760   int tag;
15761   struct riscv_attr_tag_t *attr = NULL;
15762   unsigned i;
15763
15764   tag = read_uleb128 (p, &len, end);
15765   p += len;
15766
15767   /* Find the name of attribute. */
15768   for (i = 0; i < ARRAY_SIZE (riscv_attr_tag); i++)
15769     {
15770       if (riscv_attr_tag[i].tag == tag)
15771         {
15772           attr = &riscv_attr_tag[i];
15773           break;
15774         }
15775     }
15776
15777   if (attr)
15778     printf ("  %s: ", attr->name);
15779   else
15780     return display_tag_value (tag, p, end);
15781
15782   switch (tag)
15783     {
15784     case Tag_RISCV_priv_spec:
15785     case Tag_RISCV_priv_spec_minor:
15786     case Tag_RISCV_priv_spec_revision:
15787       val = read_uleb128 (p, &len, end);
15788       p += len;
15789       printf (_("%d\n"), val);
15790       break;
15791     case Tag_RISCV_unaligned_access:
15792       val = read_uleb128 (p, &len, end);
15793       p += len;
15794       switch (val)
15795         {
15796         case 0:
15797           printf (_("No unaligned access\n"));
15798           break;
15799         case 1:
15800           printf (_("Unaligned access\n"));
15801           break;
15802         }
15803       break;
15804     case Tag_RISCV_stack_align:
15805       val = read_uleb128 (p, &len, end);
15806       p += len;
15807       printf (_("%d-bytes\n"), val);
15808       break;
15809     case Tag_RISCV_arch:
15810       p = display_tag_value (-1, p, end);
15811       break;
15812     default:
15813       return display_tag_value (tag, p, end);
15814     }
15815
15816   return p;
15817 }
15818
15819 static bfd_boolean
15820 process_attributes (Filedata * filedata,
15821                     const char * public_name,
15822                     unsigned int proc_type,
15823                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15824                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15825 {
15826   Elf_Internal_Shdr * sect;
15827   unsigned i;
15828   bfd_boolean res = TRUE;
15829
15830   /* Find the section header so that we get the size.  */
15831   for (i = 0, sect = filedata->section_headers;
15832        i < filedata->file_header.e_shnum;
15833        i++, sect++)
15834     {
15835       unsigned char * contents;
15836       unsigned char * p;
15837
15838       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15839         continue;
15840
15841       contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15842                                              sect->sh_size, _("attributes"));
15843       if (contents == NULL)
15844         {
15845           res = FALSE;
15846           continue;
15847         }
15848
15849       p = contents;
15850       /* The first character is the version of the attributes.
15851          Currently only version 1, (aka 'A') is recognised here.  */
15852       if (*p != 'A')
15853         {
15854           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15855           res = FALSE;
15856         }
15857       else
15858         {
15859           bfd_vma section_len;
15860
15861           section_len = sect->sh_size - 1;
15862           p++;
15863
15864           while (section_len > 0)
15865             {
15866               bfd_vma attr_len;
15867               unsigned int namelen;
15868               bfd_boolean public_section;
15869               bfd_boolean gnu_section;
15870
15871               if (section_len <= 4)
15872                 {
15873                   error (_("Tag section ends prematurely\n"));
15874                   res = FALSE;
15875                   break;
15876                 }
15877               attr_len = byte_get (p, 4);
15878               p += 4;
15879
15880               if (attr_len > section_len)
15881                 {
15882                   error (_("Bad attribute length (%u > %u)\n"),
15883                           (unsigned) attr_len, (unsigned) section_len);
15884                   attr_len = section_len;
15885                   res = FALSE;
15886                 }
15887               /* PR 17531: file: 001-101425-0.004  */
15888               else if (attr_len < 5)
15889                 {
15890                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
15891                   res = FALSE;
15892                   break;
15893                 }
15894
15895               section_len -= attr_len;
15896               attr_len -= 4;
15897
15898               namelen = strnlen ((char *) p, attr_len) + 1;
15899               if (namelen == 0 || namelen >= attr_len)
15900                 {
15901                   error (_("Corrupt attribute section name\n"));
15902                   res = FALSE;
15903                   break;
15904                 }
15905
15906               printf (_("Attribute Section: "));
15907               print_symbol (INT_MAX, (const char *) p);
15908               putchar ('\n');
15909
15910               if (public_name && streq ((char *) p, public_name))
15911                 public_section = TRUE;
15912               else
15913                 public_section = FALSE;
15914
15915               if (streq ((char *) p, "gnu"))
15916                 gnu_section = TRUE;
15917               else
15918                 gnu_section = FALSE;
15919
15920               p += namelen;
15921               attr_len -= namelen;
15922
15923               while (attr_len > 0 && p < contents + sect->sh_size)
15924                 {
15925                   int tag;
15926                   int val;
15927                   bfd_vma size;
15928                   unsigned char * end;
15929
15930                   /* PR binutils/17531: Safe handling of corrupt files.  */
15931                   if (attr_len < 6)
15932                     {
15933                       error (_("Unused bytes at end of section\n"));
15934                       res = FALSE;
15935                       section_len = 0;
15936                       break;
15937                     }
15938
15939                   tag = *(p++);
15940                   size = byte_get (p, 4);
15941                   if (size > attr_len)
15942                     {
15943                       error (_("Bad subsection length (%u > %u)\n"),
15944                               (unsigned) size, (unsigned) attr_len);
15945                       res = FALSE;
15946                       size = attr_len;
15947                     }
15948                   /* PR binutils/17531: Safe handling of corrupt files.  */
15949                   if (size < 6)
15950                     {
15951                       error (_("Bad subsection length (%u < 6)\n"),
15952                               (unsigned) size);
15953                       res = FALSE;
15954                       section_len = 0;
15955                       break;
15956                     }
15957
15958                   attr_len -= size;
15959                   end = p + size - 1;
15960                   assert (end <= contents + sect->sh_size);
15961                   p += 4;
15962
15963                   switch (tag)
15964                     {
15965                     case 1:
15966                       printf (_("File Attributes\n"));
15967                       break;
15968                     case 2:
15969                       printf (_("Section Attributes:"));
15970                       goto do_numlist;
15971                     case 3:
15972                       printf (_("Symbol Attributes:"));
15973                       /* Fall through.  */
15974                     do_numlist:
15975                       for (;;)
15976                         {
15977                           unsigned int j;
15978
15979                           val = read_uleb128 (p, &j, end);
15980                           p += j;
15981                           if (val == 0)
15982                             break;
15983                           printf (" %d", val);
15984                         }
15985                       printf ("\n");
15986                       break;
15987                     default:
15988                       printf (_("Unknown tag: %d\n"), tag);
15989                       public_section = FALSE;
15990                       break;
15991                     }
15992
15993                   if (public_section && display_pub_attribute != NULL)
15994                     {
15995                       while (p < end)
15996                         p = display_pub_attribute (p, end);
15997                       assert (p == end);
15998                     }
15999                   else if (gnu_section && display_proc_gnu_attribute != NULL)
16000                     {
16001                       while (p < end)
16002                         p = display_gnu_attribute (p,
16003                                                    display_proc_gnu_attribute,
16004                                                    end);
16005                       assert (p == end);
16006                     }
16007                   else if (p < end)
16008                     {
16009                       printf (_("  Unknown attribute:\n"));
16010                       display_raw_attribute (p, end);
16011                       p = end;
16012                     }
16013                   else
16014                     attr_len = 0;
16015                 }
16016             }
16017         }
16018
16019       free (contents);
16020     }
16021
16022   return res;
16023 }
16024
16025 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16026    Print the Address, Access and Initial fields of an entry at VMA ADDR
16027    and return the VMA of the next entry, or -1 if there was a problem.
16028    Does not read from DATA_END or beyond.  */
16029
16030 static bfd_vma
16031 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
16032                       unsigned char * data_end)
16033 {
16034   printf ("  ");
16035   print_vma (addr, LONG_HEX);
16036   printf (" ");
16037   if (addr < pltgot + 0xfff0)
16038     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
16039   else
16040     printf ("%10s", "");
16041   printf (" ");
16042   if (data == NULL)
16043     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
16044   else
16045     {
16046       bfd_vma entry;
16047       unsigned char * from = data + addr - pltgot;
16048
16049       if (from + (is_32bit_elf ? 4 : 8) > data_end)
16050         {
16051           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16052           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
16053           return (bfd_vma) -1;
16054         }
16055       else
16056         {
16057           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
16058           print_vma (entry, LONG_HEX);
16059         }
16060     }
16061   return addr + (is_32bit_elf ? 4 : 8);
16062 }
16063
16064 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16065    PLTGOT.  Print the Address and Initial fields of an entry at VMA
16066    ADDR and return the VMA of the next entry.  */
16067
16068 static bfd_vma
16069 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
16070 {
16071   printf ("  ");
16072   print_vma (addr, LONG_HEX);
16073   printf (" ");
16074   if (data == NULL)
16075     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
16076   else
16077     {
16078       bfd_vma entry;
16079
16080       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
16081       print_vma (entry, LONG_HEX);
16082     }
16083   return addr + (is_32bit_elf ? 4 : 8);
16084 }
16085
16086 static void
16087 print_mips_ases (unsigned int mask)
16088 {
16089   if (mask & AFL_ASE_DSP)
16090     fputs ("\n\tDSP ASE", stdout);
16091   if (mask & AFL_ASE_DSPR2)
16092     fputs ("\n\tDSP R2 ASE", stdout);
16093   if (mask & AFL_ASE_DSPR3)
16094     fputs ("\n\tDSP R3 ASE", stdout);
16095   if (mask & AFL_ASE_EVA)
16096     fputs ("\n\tEnhanced VA Scheme", stdout);
16097   if (mask & AFL_ASE_MCU)
16098     fputs ("\n\tMCU (MicroController) ASE", stdout);
16099   if (mask & AFL_ASE_MDMX)
16100     fputs ("\n\tMDMX ASE", stdout);
16101   if (mask & AFL_ASE_MIPS3D)
16102     fputs ("\n\tMIPS-3D ASE", stdout);
16103   if (mask & AFL_ASE_MT)
16104     fputs ("\n\tMT ASE", stdout);
16105   if (mask & AFL_ASE_SMARTMIPS)
16106     fputs ("\n\tSmartMIPS ASE", stdout);
16107   if (mask & AFL_ASE_VIRT)
16108     fputs ("\n\tVZ ASE", stdout);
16109   if (mask & AFL_ASE_MSA)
16110     fputs ("\n\tMSA ASE", stdout);
16111   if (mask & AFL_ASE_MIPS16)
16112     fputs ("\n\tMIPS16 ASE", stdout);
16113   if (mask & AFL_ASE_MICROMIPS)
16114     fputs ("\n\tMICROMIPS ASE", stdout);
16115   if (mask & AFL_ASE_XPA)
16116     fputs ("\n\tXPA ASE", stdout);
16117   if (mask & AFL_ASE_MIPS16E2)
16118     fputs ("\n\tMIPS16e2 ASE", stdout);
16119   if (mask & AFL_ASE_CRC)
16120     fputs ("\n\tCRC ASE", stdout);
16121   if (mask & AFL_ASE_GINV)
16122     fputs ("\n\tGINV ASE", stdout);
16123   if (mask & AFL_ASE_LOONGSON_MMI)
16124     fputs ("\n\tLoongson MMI ASE", stdout);
16125   if (mask & AFL_ASE_LOONGSON_CAM)
16126     fputs ("\n\tLoongson CAM ASE", stdout);
16127   if (mask & AFL_ASE_LOONGSON_EXT)
16128     fputs ("\n\tLoongson EXT ASE", stdout);
16129   if (mask & AFL_ASE_LOONGSON_EXT2)
16130     fputs ("\n\tLoongson EXT2 ASE", stdout);
16131   if (mask == 0)
16132     fprintf (stdout, "\n\t%s", _("None"));
16133   else if ((mask & ~AFL_ASE_MASK) != 0)
16134     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
16135 }
16136
16137 static void
16138 print_mips_isa_ext (unsigned int isa_ext)
16139 {
16140   switch (isa_ext)
16141     {
16142     case 0:
16143       fputs (_("None"), stdout);
16144       break;
16145     case AFL_EXT_XLR:
16146       fputs ("RMI XLR", stdout);
16147       break;
16148     case AFL_EXT_OCTEON3:
16149       fputs ("Cavium Networks Octeon3", stdout);
16150       break;
16151     case AFL_EXT_OCTEON2:
16152       fputs ("Cavium Networks Octeon2", stdout);
16153       break;
16154     case AFL_EXT_OCTEONP:
16155       fputs ("Cavium Networks OcteonP", stdout);
16156       break;
16157     case AFL_EXT_OCTEON:
16158       fputs ("Cavium Networks Octeon", stdout);
16159       break;
16160     case AFL_EXT_5900:
16161       fputs ("Toshiba R5900", stdout);
16162       break;
16163     case AFL_EXT_4650:
16164       fputs ("MIPS R4650", stdout);
16165       break;
16166     case AFL_EXT_4010:
16167       fputs ("LSI R4010", stdout);
16168       break;
16169     case AFL_EXT_4100:
16170       fputs ("NEC VR4100", stdout);
16171       break;
16172     case AFL_EXT_3900:
16173       fputs ("Toshiba R3900", stdout);
16174       break;
16175     case AFL_EXT_10000:
16176       fputs ("MIPS R10000", stdout);
16177       break;
16178     case AFL_EXT_SB1:
16179       fputs ("Broadcom SB-1", stdout);
16180       break;
16181     case AFL_EXT_4111:
16182       fputs ("NEC VR4111/VR4181", stdout);
16183       break;
16184     case AFL_EXT_4120:
16185       fputs ("NEC VR4120", stdout);
16186       break;
16187     case AFL_EXT_5400:
16188       fputs ("NEC VR5400", stdout);
16189       break;
16190     case AFL_EXT_5500:
16191       fputs ("NEC VR5500", stdout);
16192       break;
16193     case AFL_EXT_LOONGSON_2E:
16194       fputs ("ST Microelectronics Loongson 2E", stdout);
16195       break;
16196     case AFL_EXT_LOONGSON_2F:
16197       fputs ("ST Microelectronics Loongson 2F", stdout);
16198       break;
16199     case AFL_EXT_INTERAPTIV_MR2:
16200       fputs ("Imagination interAptiv MR2", stdout);
16201       break;
16202     default:
16203       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
16204     }
16205 }
16206
16207 static signed int
16208 get_mips_reg_size (int reg_size)
16209 {
16210   return (reg_size == AFL_REG_NONE) ? 0
16211          : (reg_size == AFL_REG_32) ? 32
16212          : (reg_size == AFL_REG_64) ? 64
16213          : (reg_size == AFL_REG_128) ? 128
16214          : -1;
16215 }
16216
16217 static bfd_boolean
16218 process_mips_specific (Filedata * filedata)
16219 {
16220   Elf_Internal_Dyn * entry;
16221   Elf_Internal_Shdr *sect = NULL;
16222   size_t liblist_offset = 0;
16223   size_t liblistno = 0;
16224   size_t conflictsno = 0;
16225   size_t options_offset = 0;
16226   size_t conflicts_offset = 0;
16227   size_t pltrelsz = 0;
16228   size_t pltrel = 0;
16229   bfd_vma pltgot = 0;
16230   bfd_vma mips_pltgot = 0;
16231   bfd_vma jmprel = 0;
16232   bfd_vma local_gotno = 0;
16233   bfd_vma gotsym = 0;
16234   bfd_vma symtabno = 0;
16235   bfd_boolean res = TRUE;
16236
16237   if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
16238                             display_mips_gnu_attribute))
16239     res = FALSE;
16240
16241   sect = find_section (filedata, ".MIPS.abiflags");
16242
16243   if (sect != NULL)
16244     {
16245       Elf_External_ABIFlags_v0 *abiflags_ext;
16246       Elf_Internal_ABIFlags_v0 abiflags_in;
16247
16248       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
16249         {
16250           error (_("Corrupt MIPS ABI Flags section.\n"));
16251           res = FALSE;
16252         }
16253       else
16254         {
16255           abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
16256                                    sect->sh_size, _("MIPS ABI Flags section"));
16257           if (abiflags_ext)
16258             {
16259               abiflags_in.version = BYTE_GET (abiflags_ext->version);
16260               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
16261               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
16262               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
16263               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
16264               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
16265               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
16266               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
16267               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
16268               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
16269               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
16270
16271               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
16272               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
16273               if (abiflags_in.isa_rev > 1)
16274                 printf ("r%d", abiflags_in.isa_rev);
16275               printf ("\nGPR size: %d",
16276                       get_mips_reg_size (abiflags_in.gpr_size));
16277               printf ("\nCPR1 size: %d",
16278                       get_mips_reg_size (abiflags_in.cpr1_size));
16279               printf ("\nCPR2 size: %d",
16280                       get_mips_reg_size (abiflags_in.cpr2_size));
16281               fputs ("\nFP ABI: ", stdout);
16282               print_mips_fp_abi_value (abiflags_in.fp_abi);
16283               fputs ("ISA Extension: ", stdout);
16284               print_mips_isa_ext (abiflags_in.isa_ext);
16285               fputs ("\nASEs:", stdout);
16286               print_mips_ases (abiflags_in.ases);
16287               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
16288               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
16289               fputc ('\n', stdout);
16290               free (abiflags_ext);
16291             }
16292         }
16293     }
16294
16295   /* We have a lot of special sections.  Thanks SGI!  */
16296   if (dynamic_section == NULL)
16297     {
16298       /* No dynamic information available.  See if there is static GOT.  */
16299       sect = find_section (filedata, ".got");
16300       if (sect != NULL)
16301         {
16302           unsigned char *data_end;
16303           unsigned char *data;
16304           bfd_vma ent, end;
16305           int addr_size;
16306
16307           pltgot = sect->sh_addr;
16308
16309           ent = pltgot;
16310           addr_size = (is_32bit_elf ? 4 : 8);
16311           end = pltgot + sect->sh_size;
16312
16313           data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
16314                                              end - pltgot, 1,
16315                                              _("Global Offset Table data"));
16316           /* PR 12855: Null data is handled gracefully throughout.  */
16317           data_end = data + (end - pltgot);
16318
16319           printf (_("\nStatic GOT:\n"));
16320           printf (_(" Canonical gp value: "));
16321           print_vma (ent + 0x7ff0, LONG_HEX);
16322           printf ("\n\n");
16323
16324           /* In a dynamic binary GOT[0] is reserved for the dynamic
16325              loader to store the lazy resolver pointer, however in
16326              a static binary it may well have been omitted and GOT
16327              reduced to a table of addresses.
16328              PR 21344: Check for the entry being fully available
16329              before fetching it.  */
16330           if (data
16331               && data + ent - pltgot + addr_size <= data_end
16332               && byte_get (data + ent - pltgot, addr_size) == 0)
16333             {
16334               printf (_(" Reserved entries:\n"));
16335               printf (_("  %*s %10s %*s\n"),
16336                       addr_size * 2, _("Address"), _("Access"),
16337                       addr_size * 2, _("Value"));
16338               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16339               printf ("\n");
16340               if (ent == (bfd_vma) -1)
16341                 goto sgot_print_fail;
16342
16343               /* Check for the MSB of GOT[1] being set, identifying a
16344                  GNU object.  This entry will be used by some runtime
16345                  loaders, to store the module pointer.  Otherwise this
16346                  is an ordinary local entry.
16347                  PR 21344: Check for the entry being fully available
16348                  before fetching it.  */
16349               if (data
16350                   && data + ent - pltgot + addr_size <= data_end
16351                   && (byte_get (data + ent - pltgot, addr_size)
16352                       >> (addr_size * 8 - 1)) != 0)
16353                 {
16354                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
16355                   printf ("\n");
16356                   if (ent == (bfd_vma) -1)
16357                     goto sgot_print_fail;
16358                 }
16359               printf ("\n");
16360             }
16361
16362           if (data != NULL && ent < end)
16363             {
16364               printf (_(" Local entries:\n"));
16365               printf ("  %*s %10s %*s\n",
16366                       addr_size * 2, _("Address"), _("Access"),
16367                       addr_size * 2, _("Value"));
16368               while (ent < end)
16369                 {
16370                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
16371                   printf ("\n");
16372                   if (ent == (bfd_vma) -1)
16373                     goto sgot_print_fail;
16374                 }
16375               printf ("\n");
16376             }
16377
16378         sgot_print_fail:
16379           if (data)
16380             free (data);
16381         }
16382       return res;
16383     }
16384
16385   for (entry = dynamic_section;
16386        /* PR 17531 file: 012-50589-0.004.  */
16387        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
16388        ++entry)
16389     switch (entry->d_tag)
16390       {
16391       case DT_MIPS_LIBLIST:
16392         liblist_offset
16393           = offset_from_vma (filedata, entry->d_un.d_val,
16394                              liblistno * sizeof (Elf32_External_Lib));
16395         break;
16396       case DT_MIPS_LIBLISTNO:
16397         liblistno = entry->d_un.d_val;
16398         break;
16399       case DT_MIPS_OPTIONS:
16400         options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
16401         break;
16402       case DT_MIPS_CONFLICT:
16403         conflicts_offset
16404           = offset_from_vma (filedata, entry->d_un.d_val,
16405                              conflictsno * sizeof (Elf32_External_Conflict));
16406         break;
16407       case DT_MIPS_CONFLICTNO:
16408         conflictsno = entry->d_un.d_val;
16409         break;
16410       case DT_PLTGOT:
16411         pltgot = entry->d_un.d_ptr;
16412         break;
16413       case DT_MIPS_LOCAL_GOTNO:
16414         local_gotno = entry->d_un.d_val;
16415         break;
16416       case DT_MIPS_GOTSYM:
16417         gotsym = entry->d_un.d_val;
16418         break;
16419       case DT_MIPS_SYMTABNO:
16420         symtabno = entry->d_un.d_val;
16421         break;
16422       case DT_MIPS_PLTGOT:
16423         mips_pltgot = entry->d_un.d_ptr;
16424         break;
16425       case DT_PLTREL:
16426         pltrel = entry->d_un.d_val;
16427         break;
16428       case DT_PLTRELSZ:
16429         pltrelsz = entry->d_un.d_val;
16430         break;
16431       case DT_JMPREL:
16432         jmprel = entry->d_un.d_ptr;
16433         break;
16434       default:
16435         break;
16436       }
16437
16438   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
16439     {
16440       Elf32_External_Lib * elib;
16441       size_t cnt;
16442
16443       elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
16444                                               liblistno,
16445                                               sizeof (Elf32_External_Lib),
16446                                               _("liblist section data"));
16447       if (elib)
16448         {
16449           printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16450                             "\nSection '.liblist' contains %lu entries:\n",
16451                             (unsigned long) liblistno),
16452                   (unsigned long) liblistno);
16453           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
16454                  stdout);
16455
16456           for (cnt = 0; cnt < liblistno; ++cnt)
16457             {
16458               Elf32_Lib liblist;
16459               time_t atime;
16460               char timebuf[128];
16461               struct tm * tmp;
16462
16463               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16464               atime = BYTE_GET (elib[cnt].l_time_stamp);
16465               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16466               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16467               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16468
16469               tmp = gmtime (&atime);
16470               snprintf (timebuf, sizeof (timebuf),
16471                         "%04u-%02u-%02uT%02u:%02u:%02u",
16472                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16473                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16474
16475               printf ("%3lu: ", (unsigned long) cnt);
16476               if (VALID_DYNAMIC_NAME (liblist.l_name))
16477                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
16478               else
16479                 printf (_("<corrupt: %9ld>"), liblist.l_name);
16480               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
16481                       liblist.l_version);
16482
16483               if (liblist.l_flags == 0)
16484                 puts (_(" NONE"));
16485               else
16486                 {
16487                   static const struct
16488                   {
16489                     const char * name;
16490                     int bit;
16491                   }
16492                   l_flags_vals[] =
16493                   {
16494                     { " EXACT_MATCH", LL_EXACT_MATCH },
16495                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
16496                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
16497                     { " EXPORTS", LL_EXPORTS },
16498                     { " DELAY_LOAD", LL_DELAY_LOAD },
16499                     { " DELTA", LL_DELTA }
16500                   };
16501                   int flags = liblist.l_flags;
16502                   size_t fcnt;
16503
16504                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
16505                     if ((flags & l_flags_vals[fcnt].bit) != 0)
16506                       {
16507                         fputs (l_flags_vals[fcnt].name, stdout);
16508                         flags ^= l_flags_vals[fcnt].bit;
16509                       }
16510                   if (flags != 0)
16511                     printf (" %#x", (unsigned int) flags);
16512
16513                   puts ("");
16514                 }
16515             }
16516
16517           free (elib);
16518         }
16519       else
16520         res = FALSE;
16521     }
16522
16523   if (options_offset != 0)
16524     {
16525       Elf_External_Options * eopt;
16526       size_t offset;
16527       int cnt;
16528       sect = filedata->section_headers;
16529
16530       /* Find the section header so that we get the size.  */
16531       sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
16532       /* PR 17533 file: 012-277276-0.004.  */
16533       if (sect == NULL)
16534         {
16535           error (_("No MIPS_OPTIONS header found\n"));
16536           return FALSE;
16537         }
16538       /* PR 24243  */
16539       if (sect->sh_size < sizeof (* eopt))
16540         {
16541           error (_("The MIPS options section is too small.\n"));
16542           return FALSE;
16543         }
16544
16545       eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
16546                                                 sect->sh_size, _("options"));
16547       if (eopt)
16548         {
16549           Elf_Internal_Options * iopt;
16550           Elf_Internal_Options * option;
16551           Elf_Internal_Options * iopt_end;
16552
16553           iopt = (Elf_Internal_Options *)
16554               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
16555           if (iopt == NULL)
16556             {
16557               error (_("Out of memory allocating space for MIPS options\n"));
16558               return FALSE;
16559             }
16560
16561           offset = cnt = 0;
16562           option = iopt;
16563           iopt_end = iopt + (sect->sh_size / sizeof (eopt));
16564
16565           while (offset <= sect->sh_size - sizeof (* eopt))
16566             {
16567               Elf_External_Options * eoption;
16568
16569               eoption = (Elf_External_Options *) ((char *) eopt + offset);
16570
16571               option->kind = BYTE_GET (eoption->kind);
16572               option->size = BYTE_GET (eoption->size);
16573               option->section = BYTE_GET (eoption->section);
16574               option->info = BYTE_GET (eoption->info);
16575
16576               /* PR 17531: file: ffa0fa3b.  */
16577               if (option->size < sizeof (* eopt)
16578                   || offset + option->size > sect->sh_size)
16579                 {
16580                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
16581                   return FALSE;
16582                 }
16583               offset += option->size;
16584
16585               ++option;
16586               ++cnt;
16587             }
16588
16589           printf (ngettext ("\nSection '%s' contains %d entry:\n",
16590                             "\nSection '%s' contains %d entries:\n",
16591                             cnt),
16592                   printable_section_name (filedata, sect), cnt);
16593
16594           option = iopt;
16595           offset = 0;
16596
16597           while (cnt-- > 0)
16598             {
16599               size_t len;
16600
16601               switch (option->kind)
16602                 {
16603                 case ODK_NULL:
16604                   /* This shouldn't happen.  */
16605                   printf (" NULL       %d %lx", option->section, option->info);
16606                   break;
16607
16608                 case ODK_REGINFO:
16609                   printf (" REGINFO    ");
16610                   if (filedata->file_header.e_machine == EM_MIPS)
16611                     {
16612                       Elf32_External_RegInfo * ereg;
16613                       Elf32_RegInfo reginfo;
16614
16615                       /* 32bit form.  */
16616                       if (option + 2 > iopt_end)
16617                         {
16618                           printf (_("<corrupt>\n"));
16619                           error (_("Truncated MIPS REGINFO option\n"));
16620                           cnt = 0;
16621                           break;
16622                         }
16623
16624                       ereg = (Elf32_External_RegInfo *) (option + 1);
16625
16626                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16627                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16628                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16629                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16630                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16631                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16632
16633                       printf ("GPR %08lx  GP 0x%lx\n",
16634                               reginfo.ri_gprmask,
16635                               (unsigned long) reginfo.ri_gp_value);
16636                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
16637                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16638                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16639                     }
16640                   else
16641                     {
16642                       /* 64 bit form.  */
16643                       Elf64_External_RegInfo * ereg;
16644                       Elf64_Internal_RegInfo reginfo;
16645
16646                       if (option + 2 > iopt_end)
16647                         {
16648                           printf (_("<corrupt>\n"));
16649                           error (_("Truncated MIPS REGINFO option\n"));
16650                           cnt = 0;
16651                           break;
16652                         }
16653
16654                       ereg = (Elf64_External_RegInfo *) (option + 1);
16655                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
16656                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16657                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16658                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16659                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16660                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
16661
16662                       printf ("GPR %08lx  GP 0x",
16663                               reginfo.ri_gprmask);
16664                       printf_vma (reginfo.ri_gp_value);
16665                       printf ("\n");
16666
16667                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
16668                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16669                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16670                     }
16671                   ++option;
16672                   continue;
16673
16674                 case ODK_EXCEPTIONS:
16675                   fputs (" EXCEPTIONS fpe_min(", stdout);
16676                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
16677                   fputs (") fpe_max(", stdout);
16678                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
16679                   fputs (")", stdout);
16680
16681                   if (option->info & OEX_PAGE0)
16682                     fputs (" PAGE0", stdout);
16683                   if (option->info & OEX_SMM)
16684                     fputs (" SMM", stdout);
16685                   if (option->info & OEX_FPDBUG)
16686                     fputs (" FPDBUG", stdout);
16687                   if (option->info & OEX_DISMISS)
16688                     fputs (" DISMISS", stdout);
16689                   break;
16690
16691                 case ODK_PAD:
16692                   fputs (" PAD       ", stdout);
16693                   if (option->info & OPAD_PREFIX)
16694                     fputs (" PREFIX", stdout);
16695                   if (option->info & OPAD_POSTFIX)
16696                     fputs (" POSTFIX", stdout);
16697                   if (option->info & OPAD_SYMBOL)
16698                     fputs (" SYMBOL", stdout);
16699                   break;
16700
16701                 case ODK_HWPATCH:
16702                   fputs (" HWPATCH   ", stdout);
16703                   if (option->info & OHW_R4KEOP)
16704                     fputs (" R4KEOP", stdout);
16705                   if (option->info & OHW_R8KPFETCH)
16706                     fputs (" R8KPFETCH", stdout);
16707                   if (option->info & OHW_R5KEOP)
16708                     fputs (" R5KEOP", stdout);
16709                   if (option->info & OHW_R5KCVTL)
16710                     fputs (" R5KCVTL", stdout);
16711                   break;
16712
16713                 case ODK_FILL:
16714                   fputs (" FILL       ", stdout);
16715                   /* XXX Print content of info word?  */
16716                   break;
16717
16718                 case ODK_TAGS:
16719                   fputs (" TAGS       ", stdout);
16720                   /* XXX Print content of info word?  */
16721                   break;
16722
16723                 case ODK_HWAND:
16724                   fputs (" HWAND     ", stdout);
16725                   if (option->info & OHWA0_R4KEOP_CHECKED)
16726                     fputs (" R4KEOP_CHECKED", stdout);
16727                   if (option->info & OHWA0_R4KEOP_CLEAN)
16728                     fputs (" R4KEOP_CLEAN", stdout);
16729                   break;
16730
16731                 case ODK_HWOR:
16732                   fputs (" HWOR      ", stdout);
16733                   if (option->info & OHWA0_R4KEOP_CHECKED)
16734                     fputs (" R4KEOP_CHECKED", stdout);
16735                   if (option->info & OHWA0_R4KEOP_CLEAN)
16736                     fputs (" R4KEOP_CLEAN", stdout);
16737                   break;
16738
16739                 case ODK_GP_GROUP:
16740                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
16741                           option->info & OGP_GROUP,
16742                           (option->info & OGP_SELF) >> 16);
16743                   break;
16744
16745                 case ODK_IDENT:
16746                   printf (" IDENT     %#06lx  self-contained %#06lx",
16747                           option->info & OGP_GROUP,
16748                           (option->info & OGP_SELF) >> 16);
16749                   break;
16750
16751                 default:
16752                   /* This shouldn't happen.  */
16753                   printf (" %3d ???     %d %lx",
16754                           option->kind, option->section, option->info);
16755                   break;
16756                 }
16757
16758               len = sizeof (* eopt);
16759               while (len < option->size)
16760                 {
16761                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
16762
16763                   if (ISPRINT (datum))
16764                     printf ("%c", datum);
16765                   else
16766                     printf ("\\%03o", datum);
16767                   len ++;
16768                 }
16769               fputs ("\n", stdout);
16770
16771               offset += option->size;
16772               ++option;
16773             }
16774
16775           free (eopt);
16776         }
16777       else
16778         res = FALSE;
16779     }
16780
16781   if (conflicts_offset != 0 && conflictsno != 0)
16782     {
16783       Elf32_Conflict * iconf;
16784       size_t cnt;
16785
16786       if (dynamic_symbols == NULL)
16787         {
16788           error (_("conflict list found without a dynamic symbol table\n"));
16789           return FALSE;
16790         }
16791
16792       /* PR 21345 - print a slightly more helpful error message
16793          if we are sure that the cmalloc will fail.  */
16794       if (conflictsno * sizeof (* iconf) > filedata->file_size)
16795         {
16796           error (_("Overlarge number of conflicts detected: %lx\n"),
16797                  (long) conflictsno);
16798           return FALSE;
16799         }
16800
16801       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16802       if (iconf == NULL)
16803         {
16804           error (_("Out of memory allocating space for dynamic conflicts\n"));
16805           return FALSE;
16806         }
16807
16808       if (is_32bit_elf)
16809         {
16810           Elf32_External_Conflict * econf32;
16811
16812           econf32 = (Elf32_External_Conflict *)
16813               get_data (NULL, filedata, conflicts_offset, conflictsno,
16814                         sizeof (* econf32), _("conflict"));
16815           if (!econf32)
16816             return FALSE;
16817
16818           for (cnt = 0; cnt < conflictsno; ++cnt)
16819             iconf[cnt] = BYTE_GET (econf32[cnt]);
16820
16821           free (econf32);
16822         }
16823       else
16824         {
16825           Elf64_External_Conflict * econf64;
16826
16827           econf64 = (Elf64_External_Conflict *)
16828               get_data (NULL, filedata, conflicts_offset, conflictsno,
16829                         sizeof (* econf64), _("conflict"));
16830           if (!econf64)
16831             return FALSE;
16832
16833           for (cnt = 0; cnt < conflictsno; ++cnt)
16834             iconf[cnt] = BYTE_GET (econf64[cnt]);
16835
16836           free (econf64);
16837         }
16838
16839       printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16840                         "\nSection '.conflict' contains %lu entries:\n",
16841                         (unsigned long) conflictsno),
16842               (unsigned long) conflictsno);
16843       puts (_("  Num:    Index       Value  Name"));
16844
16845       for (cnt = 0; cnt < conflictsno; ++cnt)
16846         {
16847           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
16848
16849           if (iconf[cnt] >= num_dynamic_syms)
16850             printf (_("<corrupt symbol index>"));
16851           else
16852             {
16853               Elf_Internal_Sym * psym;
16854
16855               psym = & dynamic_symbols[iconf[cnt]];
16856               print_vma (psym->st_value, FULL_HEX);
16857               putchar (' ');
16858               if (VALID_DYNAMIC_NAME (psym->st_name))
16859                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16860               else
16861                 printf (_("<corrupt: %14ld>"), psym->st_name);
16862             }
16863           putchar ('\n');
16864         }
16865
16866       free (iconf);
16867     }
16868
16869   if (pltgot != 0 && local_gotno != 0)
16870     {
16871       bfd_vma ent, local_end, global_end;
16872       size_t i, offset;
16873       unsigned char * data;
16874       unsigned char * data_end;
16875       int addr_size;
16876
16877       ent = pltgot;
16878       addr_size = (is_32bit_elf ? 4 : 8);
16879       local_end = pltgot + local_gotno * addr_size;
16880
16881       /* PR binutils/17533 file: 012-111227-0.004  */
16882       if (symtabno < gotsym)
16883         {
16884           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16885                  (unsigned long) gotsym, (unsigned long) symtabno);
16886           return FALSE;
16887         }
16888
16889       global_end = local_end + (symtabno - gotsym) * addr_size;
16890       /* PR 17531: file: 54c91a34.  */
16891       if (global_end < local_end)
16892         {
16893           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
16894           return FALSE;
16895         }
16896
16897       offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
16898       data = (unsigned char *) get_data (NULL, filedata, offset,
16899                                          global_end - pltgot, 1,
16900                                          _("Global Offset Table data"));
16901       /* PR 12855: Null data is handled gracefully throughout.  */
16902       data_end = data + (global_end - pltgot);
16903
16904       printf (_("\nPrimary GOT:\n"));
16905       printf (_(" Canonical gp value: "));
16906       print_vma (pltgot + 0x7ff0, LONG_HEX);
16907       printf ("\n\n");
16908
16909       printf (_(" Reserved entries:\n"));
16910       printf (_("  %*s %10s %*s Purpose\n"),
16911               addr_size * 2, _("Address"), _("Access"),
16912               addr_size * 2, _("Initial"));
16913       ent = print_mips_got_entry (data, pltgot, ent, data_end);
16914       printf (_(" Lazy resolver\n"));
16915       if (ent == (bfd_vma) -1)
16916         goto got_print_fail;
16917
16918       /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16919          This entry will be used by some runtime loaders, to store the
16920          module pointer.  Otherwise this is an ordinary local entry.
16921          PR 21344: Check for the entry being fully available before
16922          fetching it.  */
16923       if (data
16924           && data + ent - pltgot + addr_size <= data_end
16925           && (byte_get (data + ent - pltgot, addr_size)
16926               >> (addr_size * 8 - 1)) != 0)
16927         {
16928           ent = print_mips_got_entry (data, pltgot, ent, data_end);
16929           printf (_(" Module pointer (GNU extension)\n"));
16930           if (ent == (bfd_vma) -1)
16931             goto got_print_fail;
16932         }
16933       printf ("\n");
16934
16935       if (data != NULL && ent < local_end)
16936         {
16937           printf (_(" Local entries:\n"));
16938           printf ("  %*s %10s %*s\n",
16939                   addr_size * 2, _("Address"), _("Access"),
16940                   addr_size * 2, _("Initial"));
16941           while (ent < local_end)
16942             {
16943               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16944               printf ("\n");
16945               if (ent == (bfd_vma) -1)
16946                 goto got_print_fail;
16947             }
16948           printf ("\n");
16949         }
16950
16951       if (data != NULL && gotsym < symtabno)
16952         {
16953           int sym_width;
16954
16955           printf (_(" Global entries:\n"));
16956           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
16957                   addr_size * 2, _("Address"),
16958                   _("Access"),
16959                   addr_size * 2, _("Initial"),
16960                   addr_size * 2, _("Sym.Val."),
16961                   _("Type"),
16962                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
16963                   _("Ndx"), _("Name"));
16964
16965           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
16966
16967           for (i = gotsym; i < symtabno; i++)
16968             {
16969               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16970               printf (" ");
16971
16972               if (dynamic_symbols == NULL)
16973                 printf (_("<no dynamic symbols>"));
16974               else if (i < num_dynamic_syms)
16975                 {
16976                   Elf_Internal_Sym * psym = dynamic_symbols + i;
16977
16978                   print_vma (psym->st_value, LONG_HEX);
16979                   printf (" %-7s %3s ",
16980                           get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16981                           get_symbol_index_type (filedata, psym->st_shndx));
16982
16983                   if (VALID_DYNAMIC_NAME (psym->st_name))
16984                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16985                   else
16986                     printf (_("<corrupt: %14ld>"), psym->st_name);
16987                 }
16988               else
16989                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16990                         (unsigned long) i);
16991
16992               printf ("\n");
16993               if (ent == (bfd_vma) -1)
16994                 break;
16995             }
16996           printf ("\n");
16997         }
16998
16999     got_print_fail:
17000       if (data)
17001         free (data);
17002     }
17003
17004   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
17005     {
17006       bfd_vma ent, end;
17007       size_t offset, rel_offset;
17008       unsigned long count, i;
17009       unsigned char * data;
17010       int addr_size, sym_width;
17011       Elf_Internal_Rela * rels;
17012
17013       rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
17014       if (pltrel == DT_RELA)
17015         {
17016           if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
17017             return FALSE;
17018         }
17019       else
17020         {
17021           if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
17022             return FALSE;
17023         }
17024
17025       ent = mips_pltgot;
17026       addr_size = (is_32bit_elf ? 4 : 8);
17027       end = mips_pltgot + (2 + count) * addr_size;
17028
17029       offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
17030       data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
17031                                          1, _("Procedure Linkage Table data"));
17032       if (data == NULL)
17033         return FALSE;
17034
17035       printf ("\nPLT GOT:\n\n");
17036       printf (_(" Reserved entries:\n"));
17037       printf (_("  %*s %*s Purpose\n"),
17038               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
17039       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
17040       printf (_(" PLT lazy resolver\n"));
17041       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
17042       printf (_(" Module pointer\n"));
17043       printf ("\n");
17044
17045       printf (_(" Entries:\n"));
17046       printf ("  %*s %*s %*s %-7s %3s %s\n",
17047               addr_size * 2, _("Address"),
17048               addr_size * 2, _("Initial"),
17049               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17050       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
17051       for (i = 0; i < count; i++)
17052         {
17053           unsigned long idx = get_reloc_symindex (rels[i].r_info);
17054
17055           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
17056           printf (" ");
17057
17058           if (idx >= num_dynamic_syms)
17059             printf (_("<corrupt symbol index: %lu>"), idx);
17060           else
17061             {
17062               Elf_Internal_Sym * psym = dynamic_symbols + idx;
17063
17064               print_vma (psym->st_value, LONG_HEX);
17065               printf (" %-7s %3s ",
17066                       get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
17067                       get_symbol_index_type (filedata, psym->st_shndx));
17068               if (VALID_DYNAMIC_NAME (psym->st_name))
17069                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
17070               else
17071                 printf (_("<corrupt: %14ld>"), psym->st_name);
17072             }
17073           printf ("\n");
17074         }
17075       printf ("\n");
17076
17077       if (data)
17078         free (data);
17079       free (rels);
17080     }
17081
17082   return res;
17083 }
17084
17085 static bfd_boolean
17086 process_nds32_specific (Filedata * filedata)
17087 {
17088   Elf_Internal_Shdr *sect = NULL;
17089
17090   sect = find_section (filedata, ".nds32_e_flags");
17091   if (sect != NULL)
17092     {
17093       unsigned int *flag;
17094
17095       printf ("\nNDS32 elf flags section:\n");
17096       flag = get_data (NULL, filedata, sect->sh_offset, 1,
17097                        sect->sh_size, _("NDS32 elf flags section"));
17098
17099       if (! flag)
17100         return FALSE;
17101
17102       switch ((*flag) & 0x3)
17103         {
17104         case 0:
17105           printf ("(VEC_SIZE):\tNo entry.\n");
17106           break;
17107         case 1:
17108           printf ("(VEC_SIZE):\t4 bytes\n");
17109           break;
17110         case 2:
17111           printf ("(VEC_SIZE):\t16 bytes\n");
17112           break;
17113         case 3:
17114           printf ("(VEC_SIZE):\treserved\n");
17115           break;
17116         }
17117     }
17118
17119   return TRUE;
17120 }
17121
17122 static bfd_boolean
17123 process_gnu_liblist (Filedata * filedata)
17124 {
17125   Elf_Internal_Shdr * section;
17126   Elf_Internal_Shdr * string_sec;
17127   Elf32_External_Lib * elib;
17128   char * strtab;
17129   size_t strtab_size;
17130   size_t cnt;
17131   unsigned long num_liblist;
17132   unsigned i;
17133   bfd_boolean res = TRUE;
17134
17135   if (! do_arch)
17136     return TRUE;
17137
17138   for (i = 0, section = filedata->section_headers;
17139        i < filedata->file_header.e_shnum;
17140        i++, section++)
17141     {
17142       switch (section->sh_type)
17143         {
17144         case SHT_GNU_LIBLIST:
17145           if (section->sh_link >= filedata->file_header.e_shnum)
17146             break;
17147
17148           elib = (Elf32_External_Lib *)
17149               get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
17150                         _("liblist section data"));
17151
17152           if (elib == NULL)
17153             {
17154               res = FALSE;
17155               break;
17156             }
17157
17158           string_sec = filedata->section_headers + section->sh_link;
17159           strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
17160                                       string_sec->sh_size,
17161                                       _("liblist string table"));
17162           if (strtab == NULL
17163               || section->sh_entsize != sizeof (Elf32_External_Lib))
17164             {
17165               free (elib);
17166               free (strtab);
17167               res = FALSE;
17168               break;
17169             }
17170           strtab_size = string_sec->sh_size;
17171
17172           num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
17173           printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17174                             "\nLibrary list section '%s' contains %lu entries:\n",
17175                             num_liblist),
17176                   printable_section_name (filedata, section),
17177                   num_liblist);
17178
17179           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
17180
17181           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
17182                ++cnt)
17183             {
17184               Elf32_Lib liblist;
17185               time_t atime;
17186               char timebuf[128];
17187               struct tm * tmp;
17188
17189               liblist.l_name = BYTE_GET (elib[cnt].l_name);
17190               atime = BYTE_GET (elib[cnt].l_time_stamp);
17191               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
17192               liblist.l_version = BYTE_GET (elib[cnt].l_version);
17193               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
17194
17195               tmp = gmtime (&atime);
17196               snprintf (timebuf, sizeof (timebuf),
17197                         "%04u-%02u-%02uT%02u:%02u:%02u",
17198                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
17199                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
17200
17201               printf ("%3lu: ", (unsigned long) cnt);
17202               if (do_wide)
17203                 printf ("%-20s", liblist.l_name < strtab_size
17204                         ? strtab + liblist.l_name : _("<corrupt>"));
17205               else
17206                 printf ("%-20.20s", liblist.l_name < strtab_size
17207                         ? strtab + liblist.l_name : _("<corrupt>"));
17208               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
17209                       liblist.l_version, liblist.l_flags);
17210             }
17211
17212           free (elib);
17213           free (strtab);
17214         }
17215     }
17216
17217   return res;
17218 }
17219
17220 static const char *
17221 get_note_type (Filedata * filedata, unsigned e_type)
17222 {
17223   static char buff[64];
17224
17225   if (filedata->file_header.e_type == ET_CORE)
17226     switch (e_type)
17227       {
17228       case NT_AUXV:
17229         return _("NT_AUXV (auxiliary vector)");
17230       case NT_PRSTATUS:
17231         return _("NT_PRSTATUS (prstatus structure)");
17232       case NT_FPREGSET:
17233         return _("NT_FPREGSET (floating point registers)");
17234       case NT_PRPSINFO:
17235         return _("NT_PRPSINFO (prpsinfo structure)");
17236       case NT_TASKSTRUCT:
17237         return _("NT_TASKSTRUCT (task structure)");
17238       case NT_PRXFPREG:
17239         return _("NT_PRXFPREG (user_xfpregs structure)");
17240       case NT_PPC_VMX:
17241         return _("NT_PPC_VMX (ppc Altivec registers)");
17242       case NT_PPC_VSX:
17243         return _("NT_PPC_VSX (ppc VSX registers)");
17244       case NT_PPC_TAR:
17245         return _("NT_PPC_TAR (ppc TAR register)");
17246       case NT_PPC_PPR:
17247         return _("NT_PPC_PPR (ppc PPR register)");
17248       case NT_PPC_DSCR:
17249         return _("NT_PPC_DSCR (ppc DSCR register)");
17250       case NT_PPC_EBB:
17251         return _("NT_PPC_EBB (ppc EBB registers)");
17252       case NT_PPC_PMU:
17253         return _("NT_PPC_PMU (ppc PMU registers)");
17254       case NT_PPC_TM_CGPR:
17255         return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17256       case NT_PPC_TM_CFPR:
17257         return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17258       case NT_PPC_TM_CVMX:
17259         return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17260       case NT_PPC_TM_CVSX:
17261         return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17262       case NT_PPC_TM_SPR:
17263         return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17264       case NT_PPC_TM_CTAR:
17265         return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17266       case NT_PPC_TM_CPPR:
17267         return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17268       case NT_PPC_TM_CDSCR:
17269         return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17270       case NT_386_TLS:
17271         return _("NT_386_TLS (x86 TLS information)");
17272       case NT_386_IOPERM:
17273         return _("NT_386_IOPERM (x86 I/O permissions)");
17274       case NT_X86_XSTATE:
17275         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17276       case NT_S390_HIGH_GPRS:
17277         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17278       case NT_S390_TIMER:
17279         return _("NT_S390_TIMER (s390 timer register)");
17280       case NT_S390_TODCMP:
17281         return _("NT_S390_TODCMP (s390 TOD comparator register)");
17282       case NT_S390_TODPREG:
17283         return _("NT_S390_TODPREG (s390 TOD programmable register)");
17284       case NT_S390_CTRS:
17285         return _("NT_S390_CTRS (s390 control registers)");
17286       case NT_S390_PREFIX:
17287         return _("NT_S390_PREFIX (s390 prefix register)");
17288       case NT_S390_LAST_BREAK:
17289         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17290       case NT_S390_SYSTEM_CALL:
17291         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17292       case NT_S390_TDB:
17293         return _("NT_S390_TDB (s390 transaction diagnostic block)");
17294       case NT_S390_VXRS_LOW:
17295         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17296       case NT_S390_VXRS_HIGH:
17297         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17298       case NT_S390_GS_CB:
17299         return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17300       case NT_S390_GS_BC:
17301         return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17302       case NT_ARM_VFP:
17303         return _("NT_ARM_VFP (arm VFP registers)");
17304       case NT_ARM_TLS:
17305         return _("NT_ARM_TLS (AArch TLS registers)");
17306       case NT_ARM_HW_BREAK:
17307         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17308       case NT_ARM_HW_WATCH:
17309         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17310       case NT_PSTATUS:
17311         return _("NT_PSTATUS (pstatus structure)");
17312       case NT_FPREGS:
17313         return _("NT_FPREGS (floating point registers)");
17314       case NT_PSINFO:
17315         return _("NT_PSINFO (psinfo structure)");
17316       case NT_LWPSTATUS:
17317         return _("NT_LWPSTATUS (lwpstatus_t structure)");
17318       case NT_LWPSINFO:
17319         return _("NT_LWPSINFO (lwpsinfo_t structure)");
17320       case NT_WIN32PSTATUS:
17321         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17322       case NT_SIGINFO:
17323         return _("NT_SIGINFO (siginfo_t data)");
17324       case NT_FILE:
17325         return _("NT_FILE (mapped files)");
17326       default:
17327         break;
17328       }
17329   else
17330     switch (e_type)
17331       {
17332       case NT_VERSION:
17333         return _("NT_VERSION (version)");
17334       case NT_ARCH:
17335         return _("NT_ARCH (architecture)");
17336       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
17337         return _("OPEN");
17338       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
17339         return _("func");
17340       default:
17341         break;
17342       }
17343
17344   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17345   return buff;
17346 }
17347
17348 static bfd_boolean
17349 print_core_note (Elf_Internal_Note *pnote)
17350 {
17351   unsigned int addr_size = is_32bit_elf ? 4 : 8;
17352   bfd_vma count, page_size;
17353   unsigned char *descdata, *filenames, *descend;
17354
17355   if (pnote->type != NT_FILE)
17356     {
17357       if (do_wide)
17358         printf ("\n");
17359       return TRUE;
17360     }
17361
17362 #ifndef BFD64
17363   if (!is_32bit_elf)
17364     {
17365       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
17366       /* Still "successful".  */
17367       return TRUE;
17368     }
17369 #endif
17370
17371   if (pnote->descsz < 2 * addr_size)
17372     {
17373       error (_("    Malformed note - too short for header\n"));
17374       return FALSE;
17375     }
17376
17377   descdata = (unsigned char *) pnote->descdata;
17378   descend = descdata + pnote->descsz;
17379
17380   if (descdata[pnote->descsz - 1] != '\0')
17381     {
17382       error (_("    Malformed note - does not end with \\0\n"));
17383       return FALSE;
17384     }
17385
17386   count = byte_get (descdata, addr_size);
17387   descdata += addr_size;
17388
17389   page_size = byte_get (descdata, addr_size);
17390   descdata += addr_size;
17391
17392   if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
17393       || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
17394     {
17395       error (_("    Malformed note - too short for supplied file count\n"));
17396       return FALSE;
17397     }
17398
17399   printf (_("    Page size: "));
17400   print_vma (page_size, DEC);
17401   printf ("\n");
17402
17403   printf (_("    %*s%*s%*s\n"),
17404           (int) (2 + 2 * addr_size), _("Start"),
17405           (int) (4 + 2 * addr_size), _("End"),
17406           (int) (4 + 2 * addr_size), _("Page Offset"));
17407   filenames = descdata + count * 3 * addr_size;
17408   while (count-- > 0)
17409     {
17410       bfd_vma start, end, file_ofs;
17411
17412       if (filenames == descend)
17413         {
17414           error (_("    Malformed note - filenames end too early\n"));
17415           return FALSE;
17416         }
17417
17418       start = byte_get (descdata, addr_size);
17419       descdata += addr_size;
17420       end = byte_get (descdata, addr_size);
17421       descdata += addr_size;
17422       file_ofs = byte_get (descdata, addr_size);
17423       descdata += addr_size;
17424
17425       printf ("    ");
17426       print_vma (start, FULL_HEX);
17427       printf ("  ");
17428       print_vma (end, FULL_HEX);
17429       printf ("  ");
17430       print_vma (file_ofs, FULL_HEX);
17431       printf ("\n        %s\n", filenames);
17432
17433       filenames += 1 + strlen ((char *) filenames);
17434     }
17435
17436   return TRUE;
17437 }
17438
17439 static const char *
17440 get_gnu_elf_note_type (unsigned e_type)
17441 {
17442   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
17443   switch (e_type)
17444     {
17445     case NT_GNU_ABI_TAG:
17446       return _("NT_GNU_ABI_TAG (ABI version tag)");
17447     case NT_GNU_HWCAP:
17448       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17449     case NT_GNU_BUILD_ID:
17450       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17451     case NT_GNU_GOLD_VERSION:
17452       return _("NT_GNU_GOLD_VERSION (gold version)");
17453     case NT_GNU_PROPERTY_TYPE_0:
17454       return _("NT_GNU_PROPERTY_TYPE_0");
17455     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
17456       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17457     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
17458       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17459     default:
17460       {
17461         static char buff[64];
17462
17463         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17464         return buff;
17465       }
17466     }
17467 }
17468
17469 static void
17470 decode_x86_compat_isa (unsigned int bitmask)
17471 {
17472   while (bitmask)
17473     {
17474       unsigned int bit = bitmask & (- bitmask);
17475
17476       bitmask &= ~ bit;
17477       switch (bit)
17478         {
17479         case GNU_PROPERTY_X86_COMPAT_ISA_1_486:
17480           printf ("i486");
17481           break;
17482         case GNU_PROPERTY_X86_COMPAT_ISA_1_586:
17483           printf ("586");
17484           break;
17485         case GNU_PROPERTY_X86_COMPAT_ISA_1_686:
17486           printf ("686");
17487           break;
17488         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE:
17489           printf ("SSE");
17490           break;
17491         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2:
17492           printf ("SSE2");
17493           break;
17494         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3:
17495           printf ("SSE3");
17496           break;
17497         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3:
17498           printf ("SSSE3");
17499           break;
17500         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1:
17501           printf ("SSE4_1");
17502           break;
17503         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2:
17504           printf ("SSE4_2");
17505           break;
17506         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX:
17507           printf ("AVX");
17508           break;
17509         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2:
17510           printf ("AVX2");
17511           break;
17512         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F:
17513           printf ("AVX512F");
17514           break;
17515         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD:
17516           printf ("AVX512CD");
17517           break;
17518         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER:
17519           printf ("AVX512ER");
17520           break;
17521         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF:
17522           printf ("AVX512PF");
17523           break;
17524         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL:
17525           printf ("AVX512VL");
17526           break;
17527         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ:
17528           printf ("AVX512DQ");
17529           break;
17530         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW:
17531           printf ("AVX512BW");
17532           break;
17533         default:
17534           printf (_("<unknown: %x>"), bit);
17535           break;
17536         }
17537       if (bitmask)
17538         printf (", ");
17539     }
17540 }
17541
17542 static void
17543 decode_x86_isa (unsigned int bitmask)
17544 {
17545   if (!bitmask)
17546     {
17547       printf (_("<None>"));
17548       return;
17549     }
17550
17551   while (bitmask)
17552     {
17553       unsigned int bit = bitmask & (- bitmask);
17554
17555       bitmask &= ~ bit;
17556       switch (bit)
17557         {
17558         case GNU_PROPERTY_X86_ISA_1_CMOV:
17559           printf ("CMOV");
17560           break;
17561         case GNU_PROPERTY_X86_ISA_1_SSE:
17562           printf ("SSE");
17563           break;
17564         case GNU_PROPERTY_X86_ISA_1_SSE2:
17565           printf ("SSE2");
17566           break;
17567         case GNU_PROPERTY_X86_ISA_1_SSE3:
17568           printf ("SSE3");
17569           break;
17570         case GNU_PROPERTY_X86_ISA_1_SSSE3:
17571           printf ("SSSE3");
17572           break;
17573         case GNU_PROPERTY_X86_ISA_1_SSE4_1:
17574           printf ("SSE4_1");
17575           break;
17576         case GNU_PROPERTY_X86_ISA_1_SSE4_2:
17577           printf ("SSE4_2");
17578           break;
17579         case GNU_PROPERTY_X86_ISA_1_AVX:
17580           printf ("AVX");
17581           break;
17582         case GNU_PROPERTY_X86_ISA_1_AVX2:
17583           printf ("AVX2");
17584           break;
17585         case GNU_PROPERTY_X86_ISA_1_FMA:
17586           printf ("FMA");
17587           break;
17588         case GNU_PROPERTY_X86_ISA_1_AVX512F:
17589           printf ("AVX512F");
17590           break;
17591         case GNU_PROPERTY_X86_ISA_1_AVX512CD:
17592           printf ("AVX512CD");
17593           break;
17594         case GNU_PROPERTY_X86_ISA_1_AVX512ER:
17595           printf ("AVX512ER");
17596           break;
17597         case GNU_PROPERTY_X86_ISA_1_AVX512PF:
17598           printf ("AVX512PF");
17599           break;
17600         case GNU_PROPERTY_X86_ISA_1_AVX512VL:
17601           printf ("AVX512VL");
17602           break;
17603         case GNU_PROPERTY_X86_ISA_1_AVX512DQ:
17604           printf ("AVX512DQ");
17605           break;
17606         case GNU_PROPERTY_X86_ISA_1_AVX512BW:
17607           printf ("AVX512BW");
17608           break;
17609         case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS:
17610           printf ("AVX512_4FMAPS");
17611           break;
17612         case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW:
17613           printf ("AVX512_4VNNIW");
17614           break;
17615         case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG:
17616           printf ("AVX512_BITALG");
17617           break;
17618         case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA:
17619           printf ("AVX512_IFMA");
17620           break;
17621         case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI:
17622           printf ("AVX512_VBMI");
17623           break;
17624         case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2:
17625           printf ("AVX512_VBMI2");
17626           break;
17627         case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI:
17628           printf ("AVX512_VNNI");
17629           break;
17630         case GNU_PROPERTY_X86_ISA_1_AVX512_BF16:
17631           printf ("AVX512_BF16");
17632           break;
17633         default:
17634           printf (_("<unknown: %x>"), bit);
17635           break;
17636         }
17637       if (bitmask)
17638         printf (", ");
17639     }
17640 }
17641
17642 static void
17643 decode_x86_feature_1 (unsigned int bitmask)
17644 {
17645   if (!bitmask)
17646     {
17647       printf (_("<None>"));
17648       return;
17649     }
17650
17651   while (bitmask)
17652     {
17653       unsigned int bit = bitmask & (- bitmask);
17654
17655       bitmask &= ~ bit;
17656       switch (bit)
17657         {
17658         case GNU_PROPERTY_X86_FEATURE_1_IBT:
17659           printf ("IBT");
17660           break;
17661         case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
17662           printf ("SHSTK");
17663           break;
17664         default:
17665           printf (_("<unknown: %x>"), bit);
17666           break;
17667         }
17668       if (bitmask)
17669         printf (", ");
17670     }
17671 }
17672
17673 static void
17674 decode_x86_feature_2 (unsigned int bitmask)
17675 {
17676   if (!bitmask)
17677     {
17678       printf (_("<None>"));
17679       return;
17680     }
17681
17682   while (bitmask)
17683     {
17684       unsigned int bit = bitmask & (- bitmask);
17685
17686       bitmask &= ~ bit;
17687       switch (bit)
17688         {
17689         case GNU_PROPERTY_X86_FEATURE_2_X86:
17690           printf ("x86");
17691           break;
17692         case GNU_PROPERTY_X86_FEATURE_2_X87:
17693           printf ("x87");
17694           break;
17695         case GNU_PROPERTY_X86_FEATURE_2_MMX:
17696           printf ("MMX");
17697           break;
17698         case GNU_PROPERTY_X86_FEATURE_2_XMM:
17699           printf ("XMM");
17700           break;
17701         case GNU_PROPERTY_X86_FEATURE_2_YMM:
17702           printf ("YMM");
17703           break;
17704         case GNU_PROPERTY_X86_FEATURE_2_ZMM:
17705           printf ("ZMM");
17706           break;
17707         case GNU_PROPERTY_X86_FEATURE_2_FXSR:
17708           printf ("FXSR");
17709           break;
17710         case GNU_PROPERTY_X86_FEATURE_2_XSAVE:
17711           printf ("XSAVE");
17712           break;
17713         case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT:
17714           printf ("XSAVEOPT");
17715           break;
17716         case GNU_PROPERTY_X86_FEATURE_2_XSAVEC:
17717           printf ("XSAVEC");
17718           break;
17719         default:
17720           printf (_("<unknown: %x>"), bit);
17721           break;
17722         }
17723       if (bitmask)
17724         printf (", ");
17725     }
17726 }
17727
17728 static void
17729 decode_aarch64_feature_1_and (unsigned int bitmask)
17730 {
17731   while (bitmask)
17732     {
17733       unsigned int bit = bitmask & (- bitmask);
17734
17735       bitmask &= ~ bit;
17736       switch (bit)
17737         {
17738         case GNU_PROPERTY_AARCH64_FEATURE_1_BTI:
17739           printf ("BTI");
17740           break;
17741
17742         case GNU_PROPERTY_AARCH64_FEATURE_1_PAC:
17743           printf ("PAC");
17744           break;
17745
17746         default:
17747           printf (_("<unknown: %x>"), bit);
17748           break;
17749         }
17750       if (bitmask)
17751         printf (", ");
17752     }
17753 }
17754
17755 static void
17756 print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
17757 {
17758   unsigned char * ptr = (unsigned char *) pnote->descdata;
17759   unsigned char * ptr_end = ptr + pnote->descsz;
17760   unsigned int    size = is_32bit_elf ? 4 : 8;
17761
17762   printf (_("      Properties: "));
17763
17764   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
17765     {
17766       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
17767       return;
17768     }
17769
17770   while (ptr < ptr_end)
17771     {
17772       unsigned int j;
17773       unsigned int type;
17774       unsigned int datasz;
17775
17776       if ((size_t) (ptr_end - ptr) < 8)
17777         {
17778           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
17779           break;
17780         }
17781
17782       type = byte_get (ptr, 4);
17783       datasz = byte_get (ptr + 4, 4);
17784
17785       ptr += 8;
17786
17787       if (datasz > (size_t) (ptr_end - ptr))
17788         {
17789           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17790                   type, datasz);
17791           break;
17792         }
17793
17794       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
17795         {
17796           if (filedata->file_header.e_machine == EM_X86_64
17797               || filedata->file_header.e_machine == EM_IAMCU
17798               || filedata->file_header.e_machine == EM_386)
17799             {
17800               unsigned int bitmask;
17801
17802               if (datasz == 4)
17803                 bitmask = byte_get (ptr, 4);
17804               else
17805                 bitmask = 0;
17806
17807               switch (type)
17808                 {
17809                 case GNU_PROPERTY_X86_ISA_1_USED:
17810                   if (datasz != 4)
17811                     printf (_("x86 ISA used: <corrupt length: %#x> "),
17812                             datasz);
17813                   else
17814                     {
17815                       printf ("x86 ISA used: ");
17816                       decode_x86_isa (bitmask);
17817                     }
17818                   goto next;
17819
17820                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
17821                   if (datasz != 4)
17822                     printf (_("x86 ISA needed: <corrupt length: %#x> "),
17823                             datasz);
17824                   else
17825                     {
17826                       printf ("x86 ISA needed: ");
17827                       decode_x86_isa (bitmask);
17828                     }
17829                   goto next;
17830
17831                 case GNU_PROPERTY_X86_FEATURE_1_AND:
17832                   if (datasz != 4)
17833                     printf (_("x86 feature: <corrupt length: %#x> "),
17834                             datasz);
17835                   else
17836                     {
17837                       printf ("x86 feature: ");
17838                       decode_x86_feature_1 (bitmask);
17839                     }
17840                   goto next;
17841
17842                 case GNU_PROPERTY_X86_FEATURE_2_USED:
17843                   if (datasz != 4)
17844                     printf (_("x86 feature used: <corrupt length: %#x> "),
17845                             datasz);
17846                   else
17847                     {
17848                       printf ("x86 feature used: ");
17849                       decode_x86_feature_2 (bitmask);
17850                     }
17851                   goto next;
17852
17853                 case GNU_PROPERTY_X86_FEATURE_2_NEEDED:
17854                   if (datasz != 4)
17855                     printf (_("x86 feature needed: <corrupt length: %#x> "), datasz);
17856                   else
17857                     {
17858                       printf ("x86 feature needed: ");
17859                       decode_x86_feature_2 (bitmask);
17860                     }
17861                   goto next;
17862
17863                 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED:
17864                   if (datasz != 4)
17865                     printf (_("x86 ISA used: <corrupt length: %#x> "),
17866                             datasz);
17867                   else
17868                     {
17869                       printf ("x86 ISA used: ");
17870                       decode_x86_compat_isa (bitmask);
17871                     }
17872                   goto next;
17873
17874                 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED:
17875                   if (datasz != 4)
17876                     printf (_("x86 ISA needed: <corrupt length: %#x> "),
17877                             datasz);
17878                   else
17879                     {
17880                       printf ("x86 ISA needed: ");
17881                       decode_x86_compat_isa (bitmask);
17882                     }
17883                   goto next;
17884
17885                 default:
17886                   break;
17887                 }
17888             }
17889           else if (filedata->file_header.e_machine == EM_AARCH64)
17890             {
17891               if (type == GNU_PROPERTY_AARCH64_FEATURE_1_AND)
17892                 {
17893                   printf ("AArch64 feature: ");
17894                   if (datasz != 4)
17895                     printf (_("<corrupt length: %#x> "), datasz);
17896                   else
17897                     decode_aarch64_feature_1_and (byte_get (ptr, 4));
17898                   goto next;
17899                 }
17900             }
17901         }
17902       else
17903         {
17904           switch (type)
17905             {
17906             case GNU_PROPERTY_STACK_SIZE:
17907               printf (_("stack size: "));
17908               if (datasz != size)
17909                 printf (_("<corrupt length: %#x> "), datasz);
17910               else
17911                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
17912               goto next;
17913
17914             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
17915               printf ("no copy on protected ");
17916               if (datasz)
17917                 printf (_("<corrupt length: %#x> "), datasz);
17918               goto next;
17919
17920             default:
17921               break;
17922             }
17923         }
17924
17925       if (type < GNU_PROPERTY_LOPROC)
17926         printf (_("<unknown type %#x data: "), type);
17927       else if (type < GNU_PROPERTY_LOUSER)
17928         printf (_("<procesor-specific type %#x data: "), type);
17929       else
17930         printf (_("<application-specific type %#x data: "), type);
17931       for (j = 0; j < datasz; ++j)
17932         printf ("%02x ", ptr[j] & 0xff);
17933       printf (">");
17934
17935 next:
17936       ptr += ((datasz + (size - 1)) & ~ (size - 1));
17937       if (ptr == ptr_end)
17938         break;
17939
17940       if (do_wide)
17941         printf (", ");
17942       else
17943         printf ("\n\t");
17944     }
17945
17946   printf ("\n");
17947 }
17948
17949 static bfd_boolean
17950 print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
17951 {
17952   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
17953   switch (pnote->type)
17954     {
17955     case NT_GNU_BUILD_ID:
17956       {
17957         unsigned long i;
17958
17959         printf (_("    Build ID: "));
17960         for (i = 0; i < pnote->descsz; ++i)
17961           printf ("%02x", pnote->descdata[i] & 0xff);
17962         printf ("\n");
17963       }
17964       break;
17965
17966     case NT_GNU_ABI_TAG:
17967       {
17968         unsigned long os, major, minor, subminor;
17969         const char *osname;
17970
17971         /* PR 17531: file: 030-599401-0.004.  */
17972         if (pnote->descsz < 16)
17973           {
17974             printf (_("    <corrupt GNU_ABI_TAG>\n"));
17975             break;
17976           }
17977
17978         os = byte_get ((unsigned char *) pnote->descdata, 4);
17979         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17980         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
17981         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
17982
17983         switch (os)
17984           {
17985           case GNU_ABI_TAG_LINUX:
17986             osname = "Linux";
17987             break;
17988           case GNU_ABI_TAG_HURD:
17989             osname = "Hurd";
17990             break;
17991           case GNU_ABI_TAG_SOLARIS:
17992             osname = "Solaris";
17993             break;
17994           case GNU_ABI_TAG_FREEBSD:
17995             osname = "FreeBSD";
17996             break;
17997           case GNU_ABI_TAG_NETBSD:
17998             osname = "NetBSD";
17999             break;
18000           case GNU_ABI_TAG_SYLLABLE:
18001             osname = "Syllable";
18002             break;
18003           case GNU_ABI_TAG_NACL:
18004             osname = "NaCl";
18005             break;
18006           default:
18007             osname = "Unknown";
18008             break;
18009           }
18010
18011         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
18012                 major, minor, subminor);
18013       }
18014       break;
18015
18016     case NT_GNU_GOLD_VERSION:
18017       {
18018         unsigned long i;
18019
18020         printf (_("    Version: "));
18021         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
18022           printf ("%c", pnote->descdata[i]);
18023         printf ("\n");
18024       }
18025       break;
18026
18027     case NT_GNU_HWCAP:
18028       {
18029         unsigned long num_entries, mask;
18030
18031         /* Hardware capabilities information.  Word 0 is the number of entries.
18032            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
18033            is a series of entries, where each entry is a single byte followed
18034            by a nul terminated string.  The byte gives the bit number to test
18035            if enabled in the bitmask.  */
18036         printf (_("      Hardware Capabilities: "));
18037         if (pnote->descsz < 8)
18038           {
18039             error (_("<corrupt GNU_HWCAP>\n"));
18040             return FALSE;
18041           }
18042         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
18043         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18044         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
18045         /* FIXME: Add code to display the entries... */
18046       }
18047       break;
18048
18049     case NT_GNU_PROPERTY_TYPE_0:
18050       print_gnu_property_note (filedata, pnote);
18051       break;
18052
18053     default:
18054       /* Handle unrecognised types.  An error message should have already been
18055          created by get_gnu_elf_note_type(), so all that we need to do is to
18056          display the data.  */
18057       {
18058         unsigned long i;
18059
18060         printf (_("    Description data: "));
18061         for (i = 0; i < pnote->descsz; ++i)
18062           printf ("%02x ", pnote->descdata[i] & 0xff);
18063         printf ("\n");
18064       }
18065       break;
18066     }
18067
18068   return TRUE;
18069 }
18070
18071 static const char *
18072 get_v850_elf_note_type (enum v850_notes n_type)
18073 {
18074   static char buff[64];
18075
18076   switch (n_type)
18077     {
18078     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
18079     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
18080     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
18081     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
18082     case V850_NOTE_CACHE_INFO: return _("Use of cache");
18083     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
18084     default:
18085       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
18086       return buff;
18087     }
18088 }
18089
18090 static bfd_boolean
18091 print_v850_note (Elf_Internal_Note * pnote)
18092 {
18093   unsigned int val;
18094
18095   if (pnote->descsz != 4)
18096     return FALSE;
18097
18098   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
18099
18100   if (val == 0)
18101     {
18102       printf (_("not set\n"));
18103       return TRUE;
18104     }
18105
18106   switch (pnote->type)
18107     {
18108     case V850_NOTE_ALIGNMENT:
18109       switch (val)
18110         {
18111         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
18112         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
18113         }
18114       break;
18115
18116     case V850_NOTE_DATA_SIZE:
18117       switch (val)
18118         {
18119         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
18120         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
18121         }
18122       break;
18123
18124     case V850_NOTE_FPU_INFO:
18125       switch (val)
18126         {
18127         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
18128         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
18129         }
18130       break;
18131
18132     case V850_NOTE_MMU_INFO:
18133     case V850_NOTE_CACHE_INFO:
18134     case V850_NOTE_SIMD_INFO:
18135       if (val == EF_RH850_SIMD)
18136         {
18137           printf (_("yes\n"));
18138           return TRUE;
18139         }
18140       break;
18141
18142     default:
18143       /* An 'unknown note type' message will already have been displayed.  */
18144       break;
18145     }
18146
18147   printf (_("unknown value: %x\n"), val);
18148   return FALSE;
18149 }
18150
18151 static bfd_boolean
18152 process_netbsd_elf_note (Elf_Internal_Note * pnote)
18153 {
18154   unsigned int version;
18155
18156   switch (pnote->type)
18157     {
18158     case NT_NETBSD_IDENT:
18159       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
18160       if ((version / 10000) % 100)
18161         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
18162                 version, version / 100000000, (version / 1000000) % 100,
18163                 (version / 10000) % 100 > 26 ? "Z" : "",
18164                 'A' + (version / 10000) % 26);
18165       else
18166         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
18167                 version, version / 100000000, (version / 1000000) % 100,
18168                 (version / 100) % 100);
18169       return TRUE;
18170
18171     case NT_NETBSD_MARCH:
18172       printf ("  NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
18173               pnote->descdata);
18174       return TRUE;
18175
18176 #ifdef   NT_NETBSD_PAX
18177     case NT_NETBSD_PAX:
18178       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
18179       printf ("  NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote->descsz,
18180               ((version & NT_NETBSD_PAX_MPROTECT) ? "+mprotect" : ""),
18181               ((version & NT_NETBSD_PAX_NOMPROTECT) ? "-mprotect" : ""),
18182               ((version & NT_NETBSD_PAX_GUARD) ? "+guard" : ""),
18183               ((version & NT_NETBSD_PAX_NOGUARD) ? "-guard" : ""),
18184               ((version & NT_NETBSD_PAX_ASLR) ? "+ASLR" : ""),
18185               ((version & NT_NETBSD_PAX_NOASLR) ? "-ASLR" : ""));
18186       return TRUE;
18187 #endif
18188
18189     default:
18190       printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
18191               pnote->type);
18192       return FALSE;
18193     }
18194 }
18195
18196 static const char *
18197 get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
18198 {
18199   switch (e_type)
18200     {
18201     case NT_FREEBSD_THRMISC:
18202       return _("NT_THRMISC (thrmisc structure)");
18203     case NT_FREEBSD_PROCSTAT_PROC:
18204       return _("NT_PROCSTAT_PROC (proc data)");
18205     case NT_FREEBSD_PROCSTAT_FILES:
18206       return _("NT_PROCSTAT_FILES (files data)");
18207     case NT_FREEBSD_PROCSTAT_VMMAP:
18208       return _("NT_PROCSTAT_VMMAP (vmmap data)");
18209     case NT_FREEBSD_PROCSTAT_GROUPS:
18210       return _("NT_PROCSTAT_GROUPS (groups data)");
18211     case NT_FREEBSD_PROCSTAT_UMASK:
18212       return _("NT_PROCSTAT_UMASK (umask data)");
18213     case NT_FREEBSD_PROCSTAT_RLIMIT:
18214       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18215     case NT_FREEBSD_PROCSTAT_OSREL:
18216       return _("NT_PROCSTAT_OSREL (osreldate data)");
18217     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
18218       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18219     case NT_FREEBSD_PROCSTAT_AUXV:
18220       return _("NT_PROCSTAT_AUXV (auxv data)");
18221     case NT_FREEBSD_PTLWPINFO:
18222       return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18223     }
18224   return get_note_type (filedata, e_type);
18225 }
18226
18227 static const char *
18228 get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
18229 {
18230   static char buff[64];
18231
18232   switch (e_type)
18233     {
18234     case NT_NETBSDCORE_PROCINFO:
18235       /* NetBSD core "procinfo" structure.  */
18236       return _("NetBSD procinfo structure");
18237
18238 #ifdef NT_NETBSDCORE_AUXV
18239     case NT_NETBSDCORE_AUXV:
18240       return _("NetBSD ELF auxiliary vector data");
18241 #endif
18242
18243     default:
18244       /* As of Jan 2002 there are no other machine-independent notes
18245          defined for NetBSD core files.  If the note type is less
18246          than the start of the machine-dependent note types, we don't
18247          understand it.  */
18248
18249       if (e_type < NT_NETBSDCORE_FIRSTMACH)
18250         {
18251           snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18252           return buff;
18253         }
18254       break;
18255     }
18256
18257   switch (filedata->file_header.e_machine)
18258     {
18259     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18260        and PT_GETFPREGS == mach+2.  */
18261
18262     case EM_OLD_ALPHA:
18263     case EM_ALPHA:
18264     case EM_SPARC:
18265     case EM_SPARC32PLUS:
18266     case EM_SPARCV9:
18267       switch (e_type)
18268         {
18269         case NT_NETBSDCORE_FIRSTMACH + 0:
18270           return _("PT_GETREGS (reg structure)");
18271         case NT_NETBSDCORE_FIRSTMACH + 2:
18272           return _("PT_GETFPREGS (fpreg structure)");
18273         default:
18274           break;
18275         }
18276       break;
18277
18278     /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18279        There's also old PT___GETREGS40 == mach + 1 for old reg
18280        structure which lacks GBR.  */
18281     case EM_SH:
18282       switch (e_type)
18283         {
18284         case NT_NETBSDCORE_FIRSTMACH + 1:
18285           return _("PT___GETREGS40 (old reg structure)");
18286         case NT_NETBSDCORE_FIRSTMACH + 3:
18287           return _("PT_GETREGS (reg structure)");
18288         case NT_NETBSDCORE_FIRSTMACH + 5:
18289           return _("PT_GETFPREGS (fpreg structure)");
18290         default:
18291           break;
18292         }
18293       break;
18294
18295     /* On all other arch's, PT_GETREGS == mach+1 and
18296        PT_GETFPREGS == mach+3.  */
18297     default:
18298       switch (e_type)
18299         {
18300         case NT_NETBSDCORE_FIRSTMACH + 1:
18301           return _("PT_GETREGS (reg structure)");
18302         case NT_NETBSDCORE_FIRSTMACH + 3:
18303           return _("PT_GETFPREGS (fpreg structure)");
18304         default:
18305           break;
18306         }
18307     }
18308
18309   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
18310             e_type - NT_NETBSDCORE_FIRSTMACH);
18311   return buff;
18312 }
18313
18314 static const char *
18315 get_stapsdt_note_type (unsigned e_type)
18316 {
18317   static char buff[64];
18318
18319   switch (e_type)
18320     {
18321     case NT_STAPSDT:
18322       return _("NT_STAPSDT (SystemTap probe descriptors)");
18323
18324     default:
18325       break;
18326     }
18327
18328   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18329   return buff;
18330 }
18331
18332 static bfd_boolean
18333 print_stapsdt_note (Elf_Internal_Note *pnote)
18334 {
18335   size_t len, maxlen;
18336   unsigned long addr_size = is_32bit_elf ? 4 : 8;
18337   char *data = pnote->descdata;
18338   char *data_end = pnote->descdata + pnote->descsz;
18339   bfd_vma pc, base_addr, semaphore;
18340   char *provider, *probe, *arg_fmt;
18341
18342   if (pnote->descsz < (addr_size * 3))
18343     goto stapdt_note_too_small;
18344
18345   pc = byte_get ((unsigned char *) data, addr_size);
18346   data += addr_size;
18347
18348   base_addr = byte_get ((unsigned char *) data, addr_size);
18349   data += addr_size;
18350
18351   semaphore = byte_get ((unsigned char *) data, addr_size);
18352   data += addr_size;
18353
18354   if (data >= data_end)
18355     goto stapdt_note_too_small;
18356   maxlen = data_end - data;
18357   len = strnlen (data, maxlen);
18358   if (len < maxlen)
18359     {
18360       provider = data;
18361       data += len + 1;
18362     }
18363   else
18364     goto stapdt_note_too_small;
18365
18366   if (data >= data_end)
18367     goto stapdt_note_too_small;
18368   maxlen = data_end - data;
18369   len = strnlen (data, maxlen);
18370   if (len < maxlen)
18371     {
18372       probe = data;
18373       data += len + 1;
18374     }
18375   else
18376     goto stapdt_note_too_small;
18377
18378   if (data >= data_end)
18379     goto stapdt_note_too_small;
18380   maxlen = data_end - data;
18381   len = strnlen (data, maxlen);
18382   if (len < maxlen)
18383     {
18384       arg_fmt = data;
18385       data += len + 1;
18386     }
18387   else
18388     goto stapdt_note_too_small;
18389
18390   printf (_("    Provider: %s\n"), provider);
18391   printf (_("    Name: %s\n"), probe);
18392   printf (_("    Location: "));
18393   print_vma (pc, FULL_HEX);
18394   printf (_(", Base: "));
18395   print_vma (base_addr, FULL_HEX);
18396   printf (_(", Semaphore: "));
18397   print_vma (semaphore, FULL_HEX);
18398   printf ("\n");
18399   printf (_("    Arguments: %s\n"), arg_fmt);
18400
18401   return data == data_end;
18402
18403  stapdt_note_too_small:
18404   printf (_("  <corrupt - note is too small>\n"));
18405   error (_("corrupt stapdt note - the data size is too small\n"));
18406   return FALSE;
18407 }
18408
18409 static const char *
18410 get_ia64_vms_note_type (unsigned e_type)
18411 {
18412   static char buff[64];
18413
18414   switch (e_type)
18415     {
18416     case NT_VMS_MHD:
18417       return _("NT_VMS_MHD (module header)");
18418     case NT_VMS_LNM:
18419       return _("NT_VMS_LNM (language name)");
18420     case NT_VMS_SRC:
18421       return _("NT_VMS_SRC (source files)");
18422     case NT_VMS_TITLE:
18423       return "NT_VMS_TITLE";
18424     case NT_VMS_EIDC:
18425       return _("NT_VMS_EIDC (consistency check)");
18426     case NT_VMS_FPMODE:
18427       return _("NT_VMS_FPMODE (FP mode)");
18428     case NT_VMS_LINKTIME:
18429       return "NT_VMS_LINKTIME";
18430     case NT_VMS_IMGNAM:
18431       return _("NT_VMS_IMGNAM (image name)");
18432     case NT_VMS_IMGID:
18433       return _("NT_VMS_IMGID (image id)");
18434     case NT_VMS_LINKID:
18435       return _("NT_VMS_LINKID (link id)");
18436     case NT_VMS_IMGBID:
18437       return _("NT_VMS_IMGBID (build id)");
18438     case NT_VMS_GSTNAM:
18439       return _("NT_VMS_GSTNAM (sym table name)");
18440     case NT_VMS_ORIG_DYN:
18441       return "NT_VMS_ORIG_DYN";
18442     case NT_VMS_PATCHTIME:
18443       return "NT_VMS_PATCHTIME";
18444     default:
18445       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18446       return buff;
18447     }
18448 }
18449
18450 static bfd_boolean
18451 print_ia64_vms_note (Elf_Internal_Note * pnote)
18452 {
18453   int maxlen = pnote->descsz;
18454
18455   if (maxlen < 2 || (unsigned long) maxlen != pnote->descsz)
18456     goto desc_size_fail;
18457
18458   switch (pnote->type)
18459     {
18460     case NT_VMS_MHD:
18461       if (maxlen <= 36)
18462         goto desc_size_fail;
18463
18464       int l = (int) strnlen (pnote->descdata + 34, maxlen - 34);
18465
18466       printf (_("    Creation date  : %.17s\n"), pnote->descdata);
18467       printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
18468       if (l + 34 < maxlen)
18469         {
18470           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
18471           if (l + 35 < maxlen)
18472             printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
18473           else
18474             printf (_("    Module version : <missing>\n"));
18475         }
18476       else
18477         {
18478           printf (_("    Module name    : <missing>\n"));
18479           printf (_("    Module version : <missing>\n"));
18480         }
18481       break;
18482
18483     case NT_VMS_LNM:
18484       printf (_("   Language: %.*s\n"), maxlen, pnote->descdata);
18485       break;
18486
18487 #ifdef BFD64
18488     case NT_VMS_FPMODE:
18489       printf (_("   Floating Point mode: "));
18490       if (maxlen < 8)
18491         goto desc_size_fail;
18492       /* FIXME: Generate an error if descsz > 8 ?  */
18493
18494       printf ("0x%016" BFD_VMA_FMT "x\n",
18495               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
18496       break;
18497
18498     case NT_VMS_LINKTIME:
18499       printf (_("   Link time: "));
18500       if (maxlen < 8)
18501         goto desc_size_fail;
18502       /* FIXME: Generate an error if descsz > 8 ?  */
18503
18504       print_vms_time
18505         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
18506       printf ("\n");
18507       break;
18508
18509     case NT_VMS_PATCHTIME:
18510       printf (_("   Patch time: "));
18511       if (maxlen < 8)
18512         goto desc_size_fail;
18513       /* FIXME: Generate an error if descsz > 8 ?  */
18514
18515       print_vms_time
18516         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
18517       printf ("\n");
18518       break;
18519
18520     case NT_VMS_ORIG_DYN:
18521       if (maxlen < 34)
18522         goto desc_size_fail;
18523
18524       printf (_("   Major id: %u,  minor id: %u\n"),
18525               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
18526               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
18527       printf (_("   Last modified  : "));
18528       print_vms_time
18529         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
18530       printf (_("\n   Link flags  : "));
18531       printf ("0x%016" BFD_VMA_FMT "x\n",
18532               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
18533       printf (_("   Header flags: 0x%08x\n"),
18534               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
18535       printf (_("   Image id    : %.*s\n"), maxlen - 32, pnote->descdata + 32);
18536       break;
18537 #endif
18538
18539     case NT_VMS_IMGNAM:
18540       printf (_("    Image name: %.*s\n"), maxlen, pnote->descdata);
18541       break;
18542
18543     case NT_VMS_GSTNAM:
18544       printf (_("    Global symbol table name: %.*s\n"), maxlen, pnote->descdata);
18545       break;
18546
18547     case NT_VMS_IMGID:
18548       printf (_("    Image id: %.*s\n"), maxlen, pnote->descdata);
18549       break;
18550
18551     case NT_VMS_LINKID:
18552       printf (_("    Linker id: %.*s\n"), maxlen, pnote->descdata);
18553       break;
18554
18555     default:
18556       return FALSE;
18557     }
18558
18559   return TRUE;
18560
18561  desc_size_fail:
18562   printf (_("  <corrupt - data size is too small>\n"));
18563   error (_("corrupt IA64 note: data size is too small\n"));
18564   return FALSE;
18565 }
18566
18567 /* Find the symbol associated with a build attribute that is attached
18568    to address OFFSET.  If PNAME is non-NULL then store the name of
18569    the symbol (if found) in the provided pointer,  Returns NULL if a
18570    symbol could not be found.  */
18571
18572 static Elf_Internal_Sym *
18573 get_symbol_for_build_attribute (Filedata *       filedata,
18574                                 unsigned long    offset,
18575                                 bfd_boolean      is_open_attr,
18576                                 const char **    pname)
18577 {
18578   static Filedata *         saved_filedata = NULL;
18579   static char *             strtab;
18580   static unsigned long      strtablen;
18581   static Elf_Internal_Sym * symtab;
18582   static unsigned long      nsyms;
18583   Elf_Internal_Sym *        saved_sym = NULL;
18584   Elf_Internal_Sym *        sym;
18585
18586   if (filedata->section_headers != NULL
18587       && (saved_filedata == NULL || filedata != saved_filedata))
18588     {
18589       Elf_Internal_Shdr * symsec;
18590
18591       /* Load the symbol and string sections.  */
18592       for (symsec = filedata->section_headers;
18593            symsec < filedata->section_headers + filedata->file_header.e_shnum;
18594            symsec ++)
18595         {
18596           if (symsec->sh_type == SHT_SYMTAB)
18597             {
18598               symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
18599
18600               if (symsec->sh_link < filedata->file_header.e_shnum)
18601                 {
18602                   Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
18603
18604                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
18605                                               1, strtab_sec->sh_size,
18606                                               _("string table"));
18607                   strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
18608                 }
18609             }
18610         }
18611       saved_filedata = filedata;
18612     }
18613
18614   if (symtab == NULL || strtab == NULL)
18615     return NULL;
18616
18617   /* Find a symbol whose value matches offset.  */
18618   for (sym = symtab; sym < symtab + nsyms; sym ++)
18619     if (sym->st_value == offset)
18620       {
18621         if (sym->st_name >= strtablen)
18622           /* Huh ?  This should not happen.  */
18623           continue;
18624
18625         if (strtab[sym->st_name] == 0)
18626           continue;
18627
18628         /* The AArch64 and ARM architectures define mapping symbols
18629            (eg $d, $x, $t) which we want to ignore.  */
18630         if (strtab[sym->st_name] == '$'
18631             && strtab[sym->st_name + 1] != 0
18632             && strtab[sym->st_name + 2] == 0)
18633           continue;
18634
18635         if (is_open_attr)
18636           {
18637             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18638                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
18639                FUNC symbols entirely.  */
18640             switch (ELF_ST_TYPE (sym->st_info))
18641               {
18642               case STT_OBJECT:
18643               case STT_FILE:
18644                 saved_sym = sym;
18645                 if (sym->st_size)
18646                   {
18647                     /* If the symbol has a size associated
18648                        with it then we can stop searching.  */
18649                     sym = symtab + nsyms;
18650                   }
18651                 continue;
18652
18653               case STT_FUNC:
18654                 /* Ignore function symbols.  */
18655                 continue;
18656
18657               default:
18658                 break;
18659               }
18660
18661             switch (ELF_ST_BIND (sym->st_info))
18662               {
18663               case STB_GLOBAL:
18664                 if (saved_sym == NULL
18665                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
18666                   saved_sym = sym;
18667                 break;
18668
18669               case STB_LOCAL:
18670                 if (saved_sym == NULL)
18671                   saved_sym = sym;
18672                 break;
18673
18674               default:
18675                 break;
18676               }
18677           }
18678         else
18679           {
18680             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
18681               continue;
18682
18683             saved_sym = sym;
18684             break;
18685           }
18686       }
18687
18688   if (saved_sym && pname)
18689     * pname = strtab + saved_sym->st_name;
18690
18691   return saved_sym;
18692 }
18693
18694 /* Returns true iff addr1 and addr2 are in the same section.  */
18695
18696 static bfd_boolean
18697 same_section (Filedata * filedata, unsigned long addr1, unsigned long addr2)
18698 {
18699   Elf_Internal_Shdr * a1;
18700   Elf_Internal_Shdr * a2;
18701
18702   a1 = find_section_by_address (filedata, addr1);
18703   a2 = find_section_by_address (filedata, addr2);
18704
18705   return a1 == a2 && a1 != NULL;
18706 }
18707
18708 static bfd_boolean
18709 print_gnu_build_attribute_description (Elf_Internal_Note *  pnote,
18710                                        Filedata *           filedata)
18711 {
18712   static unsigned long  global_offset = 0;
18713   static unsigned long  global_end = 0;
18714   static unsigned long  func_offset = 0;
18715   static unsigned long  func_end = 0;
18716
18717   Elf_Internal_Sym *    sym;
18718   const char *          name;
18719   unsigned long         start;
18720   unsigned long         end;
18721   bfd_boolean           is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
18722
18723   switch (pnote->descsz)
18724     {
18725     case 0:
18726       /* A zero-length description means that the range of
18727          the previous note of the same type should be used.  */
18728       if (is_open_attr)
18729         {
18730           if (global_end > global_offset)
18731             printf (_("    Applies to region from %#lx to %#lx\n"),
18732                     global_offset, global_end);
18733           else
18734             printf (_("    Applies to region from %#lx\n"), global_offset);
18735         }
18736       else
18737         {
18738           if (func_end > func_offset)
18739             printf (_("    Applies to region from %#lx to %#lx\n"), func_offset, func_end);
18740           else
18741             printf (_("    Applies to region from %#lx\n"), func_offset);
18742         }
18743       return TRUE;
18744
18745     case 4:
18746       start = byte_get ((unsigned char *) pnote->descdata, 4);
18747       end = 0;
18748       break;
18749
18750     case 8:
18751       if (is_32bit_elf)
18752         {
18753           /* FIXME: We should check that version 3+ notes are being used here...  */
18754           start = byte_get ((unsigned char *) pnote->descdata, 4);
18755           end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18756         }
18757       else
18758         {
18759           start = byte_get ((unsigned char *) pnote->descdata, 8);
18760           end = 0;
18761         }
18762       break;
18763
18764     case 16:
18765       start = byte_get ((unsigned char *) pnote->descdata, 8);
18766       end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
18767       break;
18768
18769     default:
18770       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
18771       printf (_("    <invalid descsz>"));
18772       return FALSE;
18773     }
18774
18775   name = NULL;
18776   sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
18777   /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18778      in order to avoid them being confused with the start address of the
18779      first function in the file...  */
18780   if (sym == NULL && is_open_attr)
18781     sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
18782                                           & name);
18783
18784   if (end == 0 && sym != NULL && sym->st_size > 0)
18785     end = start + sym->st_size;
18786
18787   if (is_open_attr)
18788     {
18789       /* FIXME: Need to properly allow for section alignment.
18790          16 is just the alignment used on x86_64.  */
18791       if (global_end > 0
18792           && start > BFD_ALIGN (global_end, 16)
18793           /* Build notes are not guaranteed to be organised in order of
18794              increasing address, but we should find the all of the notes
18795              for one section in the same place.  */
18796           && same_section (filedata, start, global_end))
18797         warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18798               global_end + 1, start - 1);
18799
18800       printf (_("    Applies to region from %#lx"), start);
18801       global_offset = start;
18802
18803       if (end)
18804         {
18805           printf (_(" to %#lx"), end);
18806           global_end = end;
18807         }
18808     }
18809   else
18810     {
18811       printf (_("    Applies to region from %#lx"), start);
18812       func_offset = start;
18813
18814       if (end)
18815         {
18816           printf (_(" to %#lx"), end);
18817           func_end = end;
18818         }
18819     }
18820
18821   if (sym && name)
18822     printf (_(" (%s)"), name);
18823
18824   printf ("\n");
18825   return TRUE;
18826 }
18827
18828 static bfd_boolean
18829 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
18830 {
18831   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
18832   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
18833   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
18834   char         name_type;
18835   char         name_attribute;
18836   const char * expected_types;
18837   const char * name = pnote->namedata;
18838   const char * text;
18839   signed int   left;
18840
18841   if (name == NULL || pnote->namesz < 2)
18842     {
18843       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18844       print_symbol (-20, _("  <corrupt name>"));
18845       return FALSE;
18846     }
18847
18848   if (do_wide)
18849     left = 28;
18850   else
18851     left = 20;
18852
18853   /* Version 2 of the spec adds a "GA" prefix to the name field.  */
18854   if (name[0] == 'G' && name[1] == 'A')
18855     {
18856       if (pnote->namesz < 4)
18857         {
18858           error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18859           print_symbol (-20, _("  <corrupt name>"));
18860           return FALSE;
18861         }
18862
18863       printf ("GA");
18864       name += 2;
18865       left -= 2;
18866     }
18867
18868   switch ((name_type = * name))
18869     {
18870     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18871     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18872     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18873     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18874       printf ("%c", * name);
18875       left --;
18876       break;
18877     default:
18878       error (_("unrecognised attribute type in name field: %d\n"), name_type);
18879       print_symbol (-20, _("<unknown name type>"));
18880       return FALSE;
18881     }
18882
18883   ++ name;
18884   text = NULL;
18885
18886   switch ((name_attribute = * name))
18887     {
18888     case GNU_BUILD_ATTRIBUTE_VERSION:
18889       text = _("<version>");
18890       expected_types = string_expected;
18891       ++ name;
18892       break;
18893     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18894       text = _("<stack prot>");
18895       expected_types = "!+*";
18896       ++ name;
18897       break;
18898     case GNU_BUILD_ATTRIBUTE_RELRO:
18899       text = _("<relro>");
18900       expected_types = bool_expected;
18901       ++ name;
18902       break;
18903     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
18904       text = _("<stack size>");
18905       expected_types = number_expected;
18906       ++ name;
18907       break;
18908     case GNU_BUILD_ATTRIBUTE_TOOL:
18909       text = _("<tool>");
18910       expected_types = string_expected;
18911       ++ name;
18912       break;
18913     case GNU_BUILD_ATTRIBUTE_ABI:
18914       text = _("<ABI>");
18915       expected_types = "$*";
18916       ++ name;
18917       break;
18918     case GNU_BUILD_ATTRIBUTE_PIC:
18919       text = _("<PIC>");
18920       expected_types = number_expected;
18921       ++ name;
18922       break;
18923     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
18924       text = _("<short enum>");
18925       expected_types = bool_expected;
18926       ++ name;
18927       break;
18928     default:
18929       if (ISPRINT (* name))
18930         {
18931           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
18932
18933           if (len > left && ! do_wide)
18934             len = left;
18935           printf ("%.*s:", len, name);
18936           left -= len;
18937           name += len;
18938         }
18939       else
18940         {
18941           static char tmpbuf [128];
18942
18943           error (_("unrecognised byte in name field: %d\n"), * name);
18944           sprintf (tmpbuf, _("<unknown:_%d>"), * name);
18945           text = tmpbuf;
18946           name ++;
18947         }
18948       expected_types = "*$!+";
18949       break;
18950     }
18951
18952   if (text)
18953     left -= printf ("%s", text);
18954
18955   if (strchr (expected_types, name_type) == NULL)
18956     warn (_("attribute does not have an expected type (%c)\n"), name_type);
18957
18958   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
18959     {
18960       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
18961              (unsigned long) pnote->namesz,
18962              (long) (name - pnote->namedata));
18963       return FALSE;
18964     }
18965
18966   if (left < 1 && ! do_wide)
18967     return TRUE;
18968
18969   switch (name_type)
18970     {
18971     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18972       {
18973         unsigned int        bytes;
18974         unsigned long long  val = 0;
18975         unsigned int        shift = 0;
18976         char *              decoded = NULL;
18977
18978         bytes = pnote->namesz - (name - pnote->namedata);
18979         if (bytes > 0)
18980           /* The -1 is because the name field is always 0 terminated, and we
18981              want to be able to ensure that the shift in the while loop below
18982              will not overflow.  */
18983           -- bytes;
18984
18985         if (bytes > sizeof (val))
18986           {
18987             error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
18988                    bytes);
18989             bytes = sizeof (val);
18990           }
18991         /* We do not bother to warn if bytes == 0 as this can
18992            happen with some early versions of the gcc plugin.  */
18993
18994         while (bytes --)
18995           {
18996             unsigned long byte = (* name ++) & 0xff;
18997
18998             val |= byte << shift;
18999             shift += 8;
19000           }
19001
19002         switch (name_attribute)
19003           {
19004           case GNU_BUILD_ATTRIBUTE_PIC:
19005             switch (val)
19006               {
19007               case 0: decoded = "static"; break;
19008               case 1: decoded = "pic"; break;
19009               case 2: decoded = "PIC"; break;
19010               case 3: decoded = "pie"; break;
19011               case 4: decoded = "PIE"; break;
19012               default: break;
19013               }
19014             break;
19015           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
19016             switch (val)
19017               {
19018                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
19019               case 0: decoded = "off"; break;
19020               case 1: decoded = "on"; break;
19021               case 2: decoded = "all"; break;
19022               case 3: decoded = "strong"; break;
19023               case 4: decoded = "explicit"; break;
19024               default: break;
19025               }
19026             break;
19027           default:
19028             break;
19029           }
19030
19031         if (decoded != NULL)
19032           {
19033             print_symbol (-left, decoded);
19034             left = 0;
19035           }
19036         else if (val == 0)
19037           {
19038             printf ("0x0");
19039             left -= 3;
19040           }
19041         else
19042           {
19043             if (do_wide)
19044               left -= printf ("0x%llx", val);
19045             else
19046               left -= printf ("0x%-.*llx", left, val);
19047           }
19048       }
19049       break;
19050     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
19051       left -= print_symbol (- left, name);
19052       break;
19053     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
19054       left -= print_symbol (- left, "true");
19055       break;
19056     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
19057       left -= print_symbol (- left, "false");
19058       break;
19059     }
19060
19061   if (do_wide && left > 0)
19062     printf ("%-*s", left, " ");
19063
19064   return TRUE;
19065 }
19066
19067 /* Note that by the ELF standard, the name field is already null byte
19068    terminated, and namesz includes the terminating null byte.
19069    I.E. the value of namesz for the name "FSF" is 4.
19070
19071    If the value of namesz is zero, there is no name present.  */
19072
19073 static bfd_boolean
19074 process_note (Elf_Internal_Note *  pnote,
19075               Filedata *           filedata)
19076 {
19077   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
19078   const char * nt;
19079
19080   if (pnote->namesz == 0)
19081     /* If there is no note name, then use the default set of
19082        note type strings.  */
19083     nt = get_note_type (filedata, pnote->type);
19084
19085   else if (const_strneq (pnote->namedata, "GNU"))
19086     /* GNU-specific object file notes.  */
19087     nt = get_gnu_elf_note_type (pnote->type);
19088
19089   else if (const_strneq (pnote->namedata, "FreeBSD"))
19090     /* FreeBSD-specific core file notes.  */
19091     nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
19092
19093   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
19094     /* NetBSD-specific core file notes.  */
19095     nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
19096
19097   else if (const_strneq (pnote->namedata, "NetBSD"))
19098     /* NetBSD-specific core file notes.  */
19099     return process_netbsd_elf_note (pnote);
19100
19101   else if (const_strneq (pnote->namedata, "PaX"))
19102     /* NetBSD-specific core file notes.  */
19103     return process_netbsd_elf_note (pnote);
19104
19105   else if (strneq (pnote->namedata, "SPU/", 4))
19106     {
19107       /* SPU-specific core file notes.  */
19108       nt = pnote->namedata + 4;
19109       name = "SPU";
19110     }
19111
19112   else if (const_strneq (pnote->namedata, "IPF/VMS"))
19113     /* VMS/ia64-specific file notes.  */
19114     nt = get_ia64_vms_note_type (pnote->type);
19115
19116   else if (const_strneq (pnote->namedata, "stapsdt"))
19117     nt = get_stapsdt_note_type (pnote->type);
19118
19119   else
19120     /* Don't recognize this note name; just use the default set of
19121        note type strings.  */
19122     nt = get_note_type (filedata, pnote->type);
19123
19124   printf ("  ");
19125
19126   if (((const_strneq (pnote->namedata, "GA")
19127         && strchr ("*$!+", pnote->namedata[2]) != NULL)
19128        || strchr ("*$!+", pnote->namedata[0]) != NULL)
19129       && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
19130           || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
19131     print_gnu_build_attribute_name (pnote);
19132   else
19133     print_symbol (-20, name);
19134
19135   if (do_wide)
19136     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
19137   else
19138     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
19139
19140   if (const_strneq (pnote->namedata, "IPF/VMS"))
19141     return print_ia64_vms_note (pnote);
19142   else if (const_strneq (pnote->namedata, "GNU"))
19143     return print_gnu_note (filedata, pnote);
19144   else if (const_strneq (pnote->namedata, "stapsdt"))
19145     return print_stapsdt_note (pnote);
19146   else if (const_strneq (pnote->namedata, "CORE"))
19147     return print_core_note (pnote);
19148   else if (((const_strneq (pnote->namedata, "GA")
19149              && strchr ("*$!+", pnote->namedata[2]) != NULL)
19150             || strchr ("*$!+", pnote->namedata[0]) != NULL)
19151            && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
19152                || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
19153     return print_gnu_build_attribute_description (pnote, filedata);
19154
19155   if (pnote->descsz)
19156     {
19157       unsigned long i;
19158
19159       printf (_("   description data: "));
19160       for (i = 0; i < pnote->descsz; i++)
19161         printf ("%02x ", pnote->descdata[i] & 0xff);
19162       if (!do_wide)
19163         printf ("\n");
19164     }
19165
19166   if (do_wide)
19167     printf ("\n");
19168
19169   return TRUE;
19170 }
19171
19172 static bfd_boolean
19173 process_notes_at (Filedata *           filedata,
19174                   Elf_Internal_Shdr *  section,
19175                   bfd_vma              offset,
19176                   bfd_vma              length,
19177                   bfd_vma              align)
19178 {
19179   Elf_External_Note * pnotes;
19180   Elf_External_Note * external;
19181   char *              end;
19182   bfd_boolean         res = TRUE;
19183
19184   if (length <= 0)
19185     return FALSE;
19186
19187   if (section)
19188     {
19189       pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
19190       if (pnotes)
19191         {
19192           if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
19193             return FALSE;
19194         }
19195     }
19196   else
19197     pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
19198                                              _("notes"));
19199
19200   if (pnotes == NULL)
19201     return FALSE;
19202
19203   external = pnotes;
19204
19205   if (section)
19206     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
19207   else
19208     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19209             (unsigned long) offset, (unsigned long) length);
19210
19211   /* NB: Some note sections may have alignment value of 0 or 1.  gABI
19212      specifies that notes should be aligned to 4 bytes in 32-bit
19213      objects and to 8 bytes in 64-bit objects.  As a Linux extension,
19214      we also support 4 byte alignment in 64-bit objects.  If section
19215      alignment is less than 4, we treate alignment as 4 bytes.   */
19216   if (align < 4)
19217     align = 4;
19218   else if (align != 4 && align != 8)
19219     {
19220       warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19221             (long) align);
19222       return FALSE;
19223     }
19224
19225   printf (_("  %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19226
19227   end = (char *) pnotes + length;
19228   while ((char *) external < end)
19229     {
19230       Elf_Internal_Note inote;
19231       size_t min_notesz;
19232       char * next;
19233       char * temp = NULL;
19234       size_t data_remaining = end - (char *) external;
19235
19236       if (!is_ia64_vms (filedata))
19237         {
19238           /* PR binutils/15191
19239              Make sure that there is enough data to read.  */
19240           min_notesz = offsetof (Elf_External_Note, name);
19241           if (data_remaining < min_notesz)
19242             {
19243               warn (ngettext ("Corrupt note: only %ld byte remains, "
19244                               "not enough for a full note\n",
19245                               "Corrupt note: only %ld bytes remain, "
19246                               "not enough for a full note\n",
19247                               data_remaining),
19248                     (long) data_remaining);
19249               break;
19250             }
19251           data_remaining -= min_notesz;
19252
19253           inote.type     = BYTE_GET (external->type);
19254           inote.namesz   = BYTE_GET (external->namesz);
19255           inote.namedata = external->name;
19256           inote.descsz   = BYTE_GET (external->descsz);
19257           inote.descdata = ((char *) external
19258                             + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
19259           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
19260           next = ((char *) external
19261                   + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
19262         }
19263       else
19264         {
19265           Elf64_External_VMS_Note *vms_external;
19266
19267           /* PR binutils/15191
19268              Make sure that there is enough data to read.  */
19269           min_notesz = offsetof (Elf64_External_VMS_Note, name);
19270           if (data_remaining < min_notesz)
19271             {
19272               warn (ngettext ("Corrupt note: only %ld byte remains, "
19273                               "not enough for a full note\n",
19274                               "Corrupt note: only %ld bytes remain, "
19275                               "not enough for a full note\n",
19276                               data_remaining),
19277                     (long) data_remaining);
19278               break;
19279             }
19280           data_remaining -= min_notesz;
19281
19282           vms_external = (Elf64_External_VMS_Note *) external;
19283           inote.type     = BYTE_GET (vms_external->type);
19284           inote.namesz   = BYTE_GET (vms_external->namesz);
19285           inote.namedata = vms_external->name;
19286           inote.descsz   = BYTE_GET (vms_external->descsz);
19287           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
19288           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
19289           next = inote.descdata + align_power (inote.descsz, 3);
19290         }
19291
19292       /* PR 17531: file: 3443835e.  */
19293       /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
19294       if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
19295           || (size_t) (inote.descdata - inote.namedata) > data_remaining
19296           || (size_t) (next - inote.descdata) < inote.descsz
19297           || ((size_t) (next - inote.descdata)
19298               > data_remaining - (size_t) (inote.descdata - inote.namedata)))
19299         {
19300           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19301                 (unsigned long) ((char *) external - (char *) pnotes));
19302           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19303                 inote.type, inote.namesz, inote.descsz, (int) align);
19304           break;
19305         }
19306
19307       external = (Elf_External_Note *) next;
19308
19309       /* Verify that name is null terminated.  It appears that at least
19310          one version of Linux (RedHat 6.0) generates corefiles that don't
19311          comply with the ELF spec by failing to include the null byte in
19312          namesz.  */
19313       if (inote.namesz > 0 && inote.namedata[inote.namesz - 1] != '\0')
19314         {
19315           if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
19316             {
19317               temp = (char *) malloc (inote.namesz + 1);
19318               if (temp == NULL)
19319                 {
19320                   error (_("Out of memory allocating space for inote name\n"));
19321                   res = FALSE;
19322                   break;
19323                 }
19324
19325               memcpy (temp, inote.namedata, inote.namesz);
19326               inote.namedata = temp;
19327             }
19328           inote.namedata[inote.namesz] = 0;
19329         }
19330
19331       if (! process_note (& inote, filedata))
19332         res = FALSE;
19333
19334       if (temp != NULL)
19335         {
19336           free (temp);
19337           temp = NULL;
19338         }
19339     }
19340
19341   free (pnotes);
19342
19343   return res;
19344 }
19345
19346 static bfd_boolean
19347 process_corefile_note_segments (Filedata * filedata)
19348 {
19349   Elf_Internal_Phdr * segment;
19350   unsigned int i;
19351   bfd_boolean res = TRUE;
19352
19353   if (! get_program_headers (filedata))
19354     return TRUE;
19355
19356   for (i = 0, segment = filedata->program_headers;
19357        i < filedata->file_header.e_phnum;
19358        i++, segment++)
19359     {
19360       if (segment->p_type == PT_NOTE)
19361         if (! process_notes_at (filedata, NULL,
19362                                 (bfd_vma) segment->p_offset,
19363                                 (bfd_vma) segment->p_filesz,
19364                                 (bfd_vma) segment->p_align))
19365           res = FALSE;
19366     }
19367
19368   return res;
19369 }
19370
19371 static bfd_boolean
19372 process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
19373 {
19374   Elf_External_Note * pnotes;
19375   Elf_External_Note * external;
19376   char * end;
19377   bfd_boolean res = TRUE;
19378
19379   if (length <= 0)
19380     return FALSE;
19381
19382   pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
19383                                            _("v850 notes"));
19384   if (pnotes == NULL)
19385     return FALSE;
19386
19387   external = pnotes;
19388   end = (char*) pnotes + length;
19389
19390   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19391           (unsigned long) offset, (unsigned long) length);
19392
19393   while ((char *) external + sizeof (Elf_External_Note) < end)
19394     {
19395       Elf_External_Note * next;
19396       Elf_Internal_Note inote;
19397
19398       inote.type     = BYTE_GET (external->type);
19399       inote.namesz   = BYTE_GET (external->namesz);
19400       inote.namedata = external->name;
19401       inote.descsz   = BYTE_GET (external->descsz);
19402       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
19403       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
19404
19405       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
19406         {
19407           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
19408           inote.descdata = inote.namedata;
19409           inote.namesz   = 0;
19410         }
19411
19412       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
19413
19414       if (   ((char *) next > end)
19415           || ((char *) next <  (char *) pnotes))
19416         {
19417           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19418                 (unsigned long) ((char *) external - (char *) pnotes));
19419           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19420                 inote.type, inote.namesz, inote.descsz);
19421           break;
19422         }
19423
19424       external = next;
19425
19426       /* Prevent out-of-bounds indexing.  */
19427       if (   inote.namedata + inote.namesz > end
19428           || inote.namedata + inote.namesz < inote.namedata)
19429         {
19430           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19431                 (unsigned long) ((char *) external - (char *) pnotes));
19432           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19433                 inote.type, inote.namesz, inote.descsz);
19434           break;
19435         }
19436
19437       printf ("  %s: ", get_v850_elf_note_type (inote.type));
19438
19439       if (! print_v850_note (& inote))
19440         {
19441           res = FALSE;
19442           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19443                   inote.namesz, inote.descsz);
19444         }
19445     }
19446
19447   free (pnotes);
19448
19449   return res;
19450 }
19451
19452 static bfd_boolean
19453 process_note_sections (Filedata * filedata)
19454 {
19455   Elf_Internal_Shdr * section;
19456   unsigned long i;
19457   unsigned int n = 0;
19458   bfd_boolean res = TRUE;
19459
19460   for (i = 0, section = filedata->section_headers;
19461        i < filedata->file_header.e_shnum && section != NULL;
19462        i++, section++)
19463     {
19464       if (section->sh_type == SHT_NOTE)
19465         {
19466           if (! process_notes_at (filedata, section,
19467                                   (bfd_vma) section->sh_offset,
19468                                   (bfd_vma) section->sh_size,
19469                                   (bfd_vma) section->sh_addralign))
19470             res = FALSE;
19471           n++;
19472         }
19473
19474       if ((   filedata->file_header.e_machine == EM_V800
19475            || filedata->file_header.e_machine == EM_V850
19476            || filedata->file_header.e_machine == EM_CYGNUS_V850)
19477           && section->sh_type == SHT_RENESAS_INFO)
19478         {
19479           if (! process_v850_notes (filedata,
19480                                     (bfd_vma) section->sh_offset,
19481                                     (bfd_vma) section->sh_size))
19482             res = FALSE;
19483           n++;
19484         }
19485     }
19486
19487   if (n == 0)
19488     /* Try processing NOTE segments instead.  */
19489     return process_corefile_note_segments (filedata);
19490
19491   return res;
19492 }
19493
19494 static bfd_boolean
19495 process_notes (Filedata * filedata)
19496 {
19497   /* If we have not been asked to display the notes then do nothing.  */
19498   if (! do_notes)
19499     return TRUE;
19500
19501   if (filedata->file_header.e_type != ET_CORE)
19502     return process_note_sections (filedata);
19503
19504   /* No program headers means no NOTE segment.  */
19505   if (filedata->file_header.e_phnum > 0)
19506     return process_corefile_note_segments (filedata);
19507
19508   printf (_("No note segments present in the core file.\n"));
19509   return TRUE;
19510 }
19511
19512 static unsigned char *
19513 display_public_gnu_attributes (unsigned char * start,
19514                                const unsigned char * const end)
19515 {
19516   printf (_("  Unknown GNU attribute: %s\n"), start);
19517
19518   start += strnlen ((char *) start, end - start);
19519   display_raw_attribute (start, end);
19520
19521   return (unsigned char *) end;
19522 }
19523
19524 static unsigned char *
19525 display_generic_attribute (unsigned char * start,
19526                            unsigned int tag,
19527                            const unsigned char * const end)
19528 {
19529   if (tag == 0)
19530     return (unsigned char *) end;
19531
19532   return display_tag_value (tag, start, end);
19533 }
19534
19535 static bfd_boolean
19536 process_arch_specific (Filedata * filedata)
19537 {
19538   if (! do_arch)
19539     return TRUE;
19540
19541   switch (filedata->file_header.e_machine)
19542     {
19543     case EM_ARC:
19544     case EM_ARC_COMPACT:
19545     case EM_ARC_COMPACT2:
19546       return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
19547                                  display_arc_attribute,
19548                                  display_generic_attribute);
19549     case EM_ARM:
19550       return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
19551                                  display_arm_attribute,
19552                                  display_generic_attribute);
19553
19554     case EM_MIPS:
19555     case EM_MIPS_RS3_LE:
19556       return process_mips_specific (filedata);
19557
19558     case EM_MSP430:
19559      return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
19560                                 display_msp430x_attribute,
19561                                 display_generic_attribute);
19562
19563     case EM_RISCV:
19564      return process_attributes (filedata, "riscv", SHT_RISCV_ATTRIBUTES,
19565                                 display_riscv_attribute,
19566                                 display_generic_attribute);
19567
19568     case EM_NDS32:
19569       return process_nds32_specific (filedata);
19570
19571     case EM_PPC:
19572     case EM_PPC64:
19573       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19574                                  display_power_gnu_attribute);
19575
19576     case EM_S390:
19577     case EM_S390_OLD:
19578       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19579                                  display_s390_gnu_attribute);
19580
19581     case EM_SPARC:
19582     case EM_SPARC32PLUS:
19583     case EM_SPARCV9:
19584       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19585                                  display_sparc_gnu_attribute);
19586
19587     case EM_TI_C6000:
19588       return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
19589                                  display_tic6x_attribute,
19590                                  display_generic_attribute);
19591
19592     default:
19593       return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
19594                                  display_public_gnu_attributes,
19595                                  display_generic_attribute);
19596     }
19597 }
19598
19599 static bfd_boolean
19600 get_file_header (Filedata * filedata)
19601 {
19602   /* Read in the identity array.  */
19603   if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
19604     return FALSE;
19605
19606   /* Determine how to read the rest of the header.  */
19607   switch (filedata->file_header.e_ident[EI_DATA])
19608     {
19609     default:
19610     case ELFDATANONE:
19611     case ELFDATA2LSB:
19612       byte_get = byte_get_little_endian;
19613       byte_put = byte_put_little_endian;
19614       break;
19615     case ELFDATA2MSB:
19616       byte_get = byte_get_big_endian;
19617       byte_put = byte_put_big_endian;
19618       break;
19619     }
19620
19621   /* For now we only support 32 bit and 64 bit ELF files.  */
19622   is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
19623
19624   /* Read in the rest of the header.  */
19625   if (is_32bit_elf)
19626     {
19627       Elf32_External_Ehdr ehdr32;
19628
19629       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
19630         return FALSE;
19631
19632       filedata->file_header.e_type      = BYTE_GET (ehdr32.e_type);
19633       filedata->file_header.e_machine   = BYTE_GET (ehdr32.e_machine);
19634       filedata->file_header.e_version   = BYTE_GET (ehdr32.e_version);
19635       filedata->file_header.e_entry     = BYTE_GET (ehdr32.e_entry);
19636       filedata->file_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
19637       filedata->file_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
19638       filedata->file_header.e_flags     = BYTE_GET (ehdr32.e_flags);
19639       filedata->file_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
19640       filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
19641       filedata->file_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
19642       filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
19643       filedata->file_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
19644       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
19645     }
19646   else
19647     {
19648       Elf64_External_Ehdr ehdr64;
19649
19650       /* If we have been compiled with sizeof (bfd_vma) == 4, then
19651          we will not be able to cope with the 64bit data found in
19652          64 ELF files.  Detect this now and abort before we start
19653          overwriting things.  */
19654       if (sizeof (bfd_vma) < 8)
19655         {
19656           error (_("This instance of readelf has been built without support for a\n\
19657 64 bit data type and so it cannot read 64 bit ELF files.\n"));
19658           return FALSE;
19659         }
19660
19661       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
19662         return FALSE;
19663
19664       filedata->file_header.e_type      = BYTE_GET (ehdr64.e_type);
19665       filedata->file_header.e_machine   = BYTE_GET (ehdr64.e_machine);
19666       filedata->file_header.e_version   = BYTE_GET (ehdr64.e_version);
19667       filedata->file_header.e_entry     = BYTE_GET (ehdr64.e_entry);
19668       filedata->file_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
19669       filedata->file_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
19670       filedata->file_header.e_flags     = BYTE_GET (ehdr64.e_flags);
19671       filedata->file_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
19672       filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
19673       filedata->file_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
19674       filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
19675       filedata->file_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
19676       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
19677     }
19678
19679   if (filedata->file_header.e_shoff)
19680     {
19681       /* There may be some extensions in the first section header.  Don't
19682          bomb if we can't read it.  */
19683       if (is_32bit_elf)
19684         get_32bit_section_headers (filedata, TRUE);
19685       else
19686         get_64bit_section_headers (filedata, TRUE);
19687     }
19688
19689   return TRUE;
19690 }
19691
19692 static void
19693 close_file (Filedata * filedata)
19694 {
19695   if (filedata)
19696     {
19697       if (filedata->handle)
19698         fclose (filedata->handle);
19699       free (filedata);
19700     }
19701 }
19702
19703 void
19704 close_debug_file (void * data)
19705 {
19706   close_file ((Filedata *) data);
19707 }
19708
19709 static Filedata *
19710 open_file (const char * pathname)
19711 {
19712   struct stat  statbuf;
19713   Filedata *   filedata = NULL;
19714
19715   if (stat (pathname, & statbuf) < 0
19716       || ! S_ISREG (statbuf.st_mode))
19717     goto fail;
19718
19719   filedata = calloc (1, sizeof * filedata);
19720   if (filedata == NULL)
19721     goto fail;
19722
19723   filedata->handle = fopen (pathname, "rb");
19724   if (filedata->handle == NULL)
19725     goto fail;
19726
19727   filedata->file_size = (bfd_size_type) statbuf.st_size;
19728   filedata->file_name = pathname;
19729
19730   if (! get_file_header (filedata))
19731     goto fail;
19732
19733   if (filedata->file_header.e_shoff)
19734     {
19735       bfd_boolean res;
19736
19737       /* Read the section headers again, this time for real.  */
19738       if (is_32bit_elf)
19739         res = get_32bit_section_headers (filedata, FALSE);
19740       else
19741         res = get_64bit_section_headers (filedata, FALSE);
19742
19743       if (!res)
19744         goto fail;
19745     }
19746
19747   return filedata;
19748
19749  fail:
19750   if (filedata)
19751     {
19752       if (filedata->handle)
19753         fclose (filedata->handle);
19754       free (filedata);
19755     }
19756   return NULL;
19757 }
19758
19759 void *
19760 open_debug_file (const char * pathname)
19761 {
19762   return open_file (pathname);
19763 }
19764
19765 /* Process one ELF object file according to the command line options.
19766    This file may actually be stored in an archive.  The file is
19767    positioned at the start of the ELF object.  Returns TRUE if no
19768    problems were encountered, FALSE otherwise.  */
19769
19770 static bfd_boolean
19771 process_object (Filedata * filedata)
19772 {
19773   bfd_boolean  have_separate_files;
19774   unsigned int i;
19775   bfd_boolean res = TRUE;
19776
19777   if (! get_file_header (filedata))
19778     {
19779       error (_("%s: Failed to read file header\n"), filedata->file_name);
19780       return FALSE;
19781     }
19782
19783   /* Initialise per file variables.  */
19784   for (i = ARRAY_SIZE (version_info); i--;)
19785     version_info[i] = 0;
19786
19787   for (i = ARRAY_SIZE (dynamic_info); i--;)
19788     dynamic_info[i] = 0;
19789   dynamic_info_DT_GNU_HASH = 0;
19790   dynamic_info_DT_MIPS_XHASH = 0;
19791
19792   /* Process the file.  */
19793   if (show_name)
19794     printf (_("\nFile: %s\n"), filedata->file_name);
19795
19796   /* Initialise the dump_sects array from the cmdline_dump_sects array.
19797      Note we do this even if cmdline_dump_sects is empty because we
19798      must make sure that the dump_sets array is zeroed out before each
19799      object file is processed.  */
19800   if (filedata->num_dump_sects > cmdline.num_dump_sects)
19801     memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
19802
19803   if (cmdline.num_dump_sects > 0)
19804     {
19805       if (filedata->num_dump_sects == 0)
19806         /* A sneaky way of allocating the dump_sects array.  */
19807         request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
19808
19809       assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
19810       memcpy (filedata->dump_sects, cmdline.dump_sects,
19811               cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
19812     }
19813
19814   if (! process_file_header (filedata))
19815     return FALSE;
19816
19817   if (! process_section_headers (filedata))
19818     {
19819       /* Without loaded section headers we cannot process lots of things.  */
19820       do_unwind = do_version = do_dump = do_arch = FALSE;
19821
19822       if (! do_using_dynamic)
19823         do_syms = do_dyn_syms = do_reloc = FALSE;
19824     }
19825
19826   if (! process_section_groups (filedata))
19827     /* Without loaded section groups we cannot process unwind.  */
19828     do_unwind = FALSE;
19829
19830   if (process_program_headers (filedata))
19831     process_dynamic_section (filedata);
19832   else
19833     res = FALSE;
19834
19835   if (! process_relocs (filedata))
19836     res = FALSE;
19837
19838   if (! process_unwind (filedata))
19839     res = FALSE;
19840
19841   if (! process_symbol_table (filedata))
19842     res = FALSE;
19843
19844   if (! process_syminfo (filedata))
19845     res = FALSE;
19846
19847   if (! process_version_sections (filedata))
19848     res = FALSE;
19849
19850   if (filedata->file_header.e_shstrndx != SHN_UNDEF)
19851     have_separate_files = load_separate_debug_files (filedata, filedata->file_name);
19852   else
19853     have_separate_files = FALSE;
19854
19855   if (! process_section_contents (filedata))
19856     res = FALSE;
19857
19858   if (have_separate_files)
19859     {
19860       separate_info * d;
19861
19862       for (d = first_separate_info; d != NULL; d = d->next)
19863         {
19864           if (! process_section_headers (d->handle))
19865             res = FALSE;
19866           else if (! process_section_contents (d->handle))
19867             res = FALSE;
19868         }
19869
19870       /* The file handles are closed by the call to free_debug_memory() below.  */
19871     }
19872
19873   if (! process_notes (filedata))
19874     res = FALSE;
19875
19876   if (! process_gnu_liblist (filedata))
19877     res = FALSE;
19878
19879   if (! process_arch_specific (filedata))
19880     res = FALSE;
19881
19882   free (filedata->program_headers);
19883   filedata->program_headers = NULL;
19884
19885   free (filedata->section_headers);
19886   filedata->section_headers = NULL;
19887
19888   free (filedata->string_table);
19889   filedata->string_table = NULL;
19890   filedata->string_table_length = 0;
19891
19892   if (dynamic_strings)
19893     {
19894       free (dynamic_strings);
19895       dynamic_strings = NULL;
19896       dynamic_strings_length = 0;
19897     }
19898
19899   if (dynamic_symbols)
19900     {
19901       free (dynamic_symbols);
19902       dynamic_symbols = NULL;
19903       num_dynamic_syms = 0;
19904     }
19905
19906   if (dynamic_syminfo)
19907     {
19908       free (dynamic_syminfo);
19909       dynamic_syminfo = NULL;
19910     }
19911
19912   if (dynamic_section)
19913     {
19914       free (dynamic_section);
19915       dynamic_section = NULL;
19916     }
19917
19918   if (section_headers_groups)
19919     {
19920       free (section_headers_groups);
19921       section_headers_groups = NULL;
19922     }
19923
19924   if (section_groups)
19925     {
19926       struct group_list * g;
19927       struct group_list * next;
19928
19929       for (i = 0; i < group_count; i++)
19930         {
19931           for (g = section_groups [i].root; g != NULL; g = next)
19932             {
19933               next = g->next;
19934               free (g);
19935             }
19936         }
19937
19938       free (section_groups);
19939       section_groups = NULL;
19940     }
19941
19942   free_debug_memory ();
19943
19944   return res;
19945 }
19946
19947 /* Process an ELF archive.
19948    On entry the file is positioned just after the ARMAG string.
19949    Returns TRUE upon success, FALSE otherwise.  */
19950
19951 static bfd_boolean
19952 process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
19953 {
19954   struct archive_info arch;
19955   struct archive_info nested_arch;
19956   size_t got;
19957   bfd_boolean ret = TRUE;
19958
19959   show_name = TRUE;
19960
19961   /* The ARCH structure is used to hold information about this archive.  */
19962   arch.file_name = NULL;
19963   arch.file = NULL;
19964   arch.index_array = NULL;
19965   arch.sym_table = NULL;
19966   arch.longnames = NULL;
19967
19968   /* The NESTED_ARCH structure is used as a single-item cache of information
19969      about a nested archive (when members of a thin archive reside within
19970      another regular archive file).  */
19971   nested_arch.file_name = NULL;
19972   nested_arch.file = NULL;
19973   nested_arch.index_array = NULL;
19974   nested_arch.sym_table = NULL;
19975   nested_arch.longnames = NULL;
19976
19977   if (setup_archive (&arch, filedata->file_name, filedata->handle,
19978                      is_thin_archive, do_archive_index) != 0)
19979     {
19980       ret = FALSE;
19981       goto out;
19982     }
19983
19984   if (do_archive_index)
19985     {
19986       if (arch.sym_table == NULL)
19987         error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
19988       else
19989         {
19990           unsigned long i, l;
19991           unsigned long current_pos;
19992
19993           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
19994                   filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
19995
19996           current_pos = ftell (filedata->handle);
19997
19998           for (i = l = 0; i < arch.index_num; i++)
19999             {
20000               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
20001                 {
20002                   char * member_name;
20003
20004                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
20005
20006                   if (member_name != NULL)
20007                     {
20008                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
20009
20010                       if (qualified_name != NULL)
20011                         {
20012                           printf (_("Contents of binary %s at offset "), qualified_name);
20013                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
20014                           putchar ('\n');
20015                           free (qualified_name);
20016                         }
20017                     }
20018                 }
20019
20020               if (l >= arch.sym_size)
20021                 {
20022                   error (_("%s: end of the symbol table reached before the end of the index\n"),
20023                          filedata->file_name);
20024                   ret = FALSE;
20025                   break;
20026                 }
20027               /* PR 17531: file: 0b6630b2.  */
20028               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
20029               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
20030             }
20031
20032           if (arch.uses_64bit_indices)
20033             l = (l + 7) & ~ 7;
20034           else
20035             l += l & 1;
20036
20037           if (l < arch.sym_size)
20038             {
20039               error (ngettext ("%s: %ld byte remains in the symbol table, "
20040                                "but without corresponding entries in "
20041                                "the index table\n",
20042                                "%s: %ld bytes remain in the symbol table, "
20043                                "but without corresponding entries in "
20044                                "the index table\n",
20045                                arch.sym_size - l),
20046                      filedata->file_name, arch.sym_size - l);
20047               ret = FALSE;
20048             }
20049
20050           if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
20051             {
20052               error (_("%s: failed to seek back to start of object files in the archive\n"),
20053                      filedata->file_name);
20054               ret = FALSE;
20055               goto out;
20056             }
20057         }
20058
20059       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
20060           && !do_segments && !do_header && !do_dump && !do_version
20061           && !do_histogram && !do_debugging && !do_arch && !do_notes
20062           && !do_section_groups && !do_dyn_syms)
20063         {
20064           ret = TRUE; /* Archive index only.  */
20065           goto out;
20066         }
20067     }
20068
20069   while (1)
20070     {
20071       char * name;
20072       size_t namelen;
20073       char * qualified_name;
20074
20075       /* Read the next archive header.  */
20076       if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
20077         {
20078           error (_("%s: failed to seek to next archive header\n"), arch.file_name);
20079           return FALSE;
20080         }
20081       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
20082       if (got != sizeof arch.arhdr)
20083         {
20084           if (got == 0)
20085             break;
20086           /* PR 24049 - we cannot use filedata->file_name as this will
20087              have already been freed.  */
20088           error (_("%s: failed to read archive header\n"), arch.file_name);
20089
20090           ret = FALSE;
20091           break;
20092         }
20093       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
20094         {
20095           error (_("%s: did not find a valid archive header\n"), arch.file_name);
20096           ret = FALSE;
20097           break;
20098         }
20099
20100       arch.next_arhdr_offset += sizeof arch.arhdr;
20101
20102       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
20103       if (archive_file_size & 01)
20104         ++archive_file_size;
20105
20106       name = get_archive_member_name (&arch, &nested_arch);
20107       if (name == NULL)
20108         {
20109           error (_("%s: bad archive file name\n"), arch.file_name);
20110           ret = FALSE;
20111           break;
20112         }
20113       namelen = strlen (name);
20114
20115       qualified_name = make_qualified_name (&arch, &nested_arch, name);
20116       if (qualified_name == NULL)
20117         {
20118           error (_("%s: bad archive file name\n"), arch.file_name);
20119           ret = FALSE;
20120           break;
20121         }
20122
20123       if (is_thin_archive && arch.nested_member_origin == 0)
20124         {
20125           /* This is a proxy for an external member of a thin archive.  */
20126           Filedata * member_filedata;
20127           char * member_file_name = adjust_relative_path
20128             (filedata->file_name, name, namelen);
20129
20130           if (member_file_name == NULL)
20131             {
20132               ret = FALSE;
20133               break;
20134             }
20135
20136           member_filedata = open_file (member_file_name);
20137           if (member_filedata == NULL)
20138             {
20139               error (_("Input file '%s' is not readable.\n"), member_file_name);
20140               free (member_file_name);
20141               ret = FALSE;
20142               break;
20143             }
20144
20145           archive_file_offset = arch.nested_member_origin;
20146           member_filedata->file_name = qualified_name;
20147
20148           if (! process_object (member_filedata))
20149             ret = FALSE;
20150
20151           close_file (member_filedata);
20152           free (member_file_name);
20153         }
20154       else if (is_thin_archive)
20155         {
20156           Filedata thin_filedata;
20157
20158           memset (&thin_filedata, 0, sizeof (thin_filedata));
20159
20160           /* PR 15140: Allow for corrupt thin archives.  */
20161           if (nested_arch.file == NULL)
20162             {
20163               error (_("%s: contains corrupt thin archive: %s\n"),
20164                      qualified_name, name);
20165               ret = FALSE;
20166               break;
20167             }
20168
20169           /* This is a proxy for a member of a nested archive.  */
20170           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
20171
20172           /* The nested archive file will have been opened and setup by
20173              get_archive_member_name.  */
20174           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
20175             {
20176               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
20177               ret = FALSE;
20178               break;
20179             }
20180
20181           thin_filedata.handle = nested_arch.file;
20182           thin_filedata.file_name = qualified_name;
20183
20184           if (! process_object (& thin_filedata))
20185             ret = FALSE;
20186         }
20187       else
20188         {
20189           archive_file_offset = arch.next_arhdr_offset;
20190           arch.next_arhdr_offset += archive_file_size;
20191
20192           filedata->file_name = qualified_name;
20193           if (! process_object (filedata))
20194             ret = FALSE;
20195         }
20196
20197       if (filedata->dump_sects != NULL)
20198         {
20199           free (filedata->dump_sects);
20200           filedata->dump_sects = NULL;
20201           filedata->num_dump_sects = 0;
20202         }
20203
20204       free (qualified_name);
20205     }
20206
20207  out:
20208   if (nested_arch.file != NULL)
20209     fclose (nested_arch.file);
20210   release_archive (&nested_arch);
20211   release_archive (&arch);
20212
20213   return ret;
20214 }
20215
20216 static bfd_boolean
20217 process_file (char * file_name)
20218 {
20219   Filedata * filedata = NULL;
20220   struct stat statbuf;
20221   char armag[SARMAG];
20222   bfd_boolean ret = TRUE;
20223
20224   if (stat (file_name, &statbuf) < 0)
20225     {
20226       if (errno == ENOENT)
20227         error (_("'%s': No such file\n"), file_name);
20228       else
20229         error (_("Could not locate '%s'.  System error message: %s\n"),
20230                file_name, strerror (errno));
20231       return FALSE;
20232     }
20233
20234   if (! S_ISREG (statbuf.st_mode))
20235     {
20236       error (_("'%s' is not an ordinary file\n"), file_name);
20237       return FALSE;
20238     }
20239
20240   filedata = calloc (1, sizeof * filedata);
20241   if (filedata == NULL)
20242     {
20243       error (_("Out of memory allocating file data structure\n"));
20244       return FALSE;
20245     }
20246
20247   filedata->file_name = file_name;
20248   filedata->handle = fopen (file_name, "rb");
20249   if (filedata->handle == NULL)
20250     {
20251       error (_("Input file '%s' is not readable.\n"), file_name);
20252       free (filedata);
20253       return FALSE;
20254     }
20255
20256   if (fread (armag, SARMAG, 1, filedata->handle) != 1)
20257     {
20258       error (_("%s: Failed to read file's magic number\n"), file_name);
20259       fclose (filedata->handle);
20260       free (filedata);
20261       return FALSE;
20262     }
20263
20264   filedata->file_size = (bfd_size_type) statbuf.st_size;
20265
20266   if (memcmp (armag, ARMAG, SARMAG) == 0)
20267     {
20268       if (! process_archive (filedata, FALSE))
20269         ret = FALSE;
20270     }
20271   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
20272     {
20273       if ( ! process_archive (filedata, TRUE))
20274         ret = FALSE;
20275     }
20276   else
20277     {
20278       if (do_archive_index)
20279         error (_("File %s is not an archive so its index cannot be displayed.\n"),
20280                file_name);
20281
20282       rewind (filedata->handle);
20283       archive_file_size = archive_file_offset = 0;
20284
20285       if (! process_object (filedata))
20286         ret = FALSE;
20287     }
20288
20289   fclose (filedata->handle);
20290   free (filedata);
20291
20292   return ret;
20293 }
20294
20295 #ifdef SUPPORT_DISASSEMBLY
20296 /* Needed by the i386 disassembler.  For extra credit, someone could
20297    fix this so that we insert symbolic addresses here, esp for GOT/PLT
20298    symbols.  */
20299
20300 void
20301 print_address (unsigned int addr, FILE * outfile)
20302 {
20303   fprintf (outfile,"0x%8.8x", addr);
20304 }
20305
20306 /* Needed by the i386 disassembler.  */
20307
20308 void
20309 db_task_printsym (unsigned int addr)
20310 {
20311   print_address (addr, stderr);
20312 }
20313 #endif
20314
20315 int
20316 main (int argc, char ** argv)
20317 {
20318   int err;
20319
20320 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20321   setlocale (LC_MESSAGES, "");
20322 #endif
20323 #if defined (HAVE_SETLOCALE)
20324   setlocale (LC_CTYPE, "");
20325 #endif
20326   bindtextdomain (PACKAGE, LOCALEDIR);
20327   textdomain (PACKAGE);
20328
20329   expandargv (&argc, &argv);
20330
20331   cmdline.file_name = "<cmdline>";
20332   parse_args (& cmdline, argc, argv);
20333
20334   if (optind < (argc - 1))
20335     show_name = TRUE;
20336   else if (optind >= argc)
20337     {
20338       warn (_("Nothing to do.\n"));
20339       usage (stderr);
20340     }
20341
20342   err = FALSE;
20343   while (optind < argc)
20344     if (! process_file (argv[optind++]))
20345       err = TRUE;
20346
20347   if (cmdline.dump_sects != NULL)
20348     free (cmdline.dump_sects);
20349
20350   free (dump_ctf_symtab_name);
20351   free (dump_ctf_strtab_name);
20352   free (dump_ctf_parent_name);
20353
20354   return err ? EXIT_FAILURE : EXIT_SUCCESS;
20355 }