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
  64 #include "elf/common.h"
  65 #include "elf/external.h"
  66 #include "elf/internal.h"
  67
  68
  69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
  70    we can obtain the H8 reloc numbers.  We need these for the
  71    get_reloc_size() function.  We include h8.h again after defining
  72    RELOC_MACROS_GEN_FUNC so that we get the naming function as well.  */
  73
  74 #include "elf/h8.h"
  75 #undef _ELF_H8_H
  76
  77 /* Undo the effects of #including reloc-macros.h.  */
  78
  79 #undef START_RELOC_NUMBERS
  80 #undef RELOC_NUMBER
  81 #undef FAKE_RELOC
  82 #undef EMPTY_RELOC
  83 #undef END_RELOC_NUMBERS
  84 #undef _RELOC_MACROS_H
  85
  86 /* The following headers use the elf/reloc-macros.h file to
  87    automatically generate relocation recognition functions
  88    such as elf_mips_reloc_type()  */
  89
  90 #define RELOC_MACROS_GEN_FUNC
  91
  92 #include "elf/aarch64.h"
  93 #include "elf/alpha.h"
  94 #include "elf/arc.h"
  95 #include "elf/arm.h"
  96 #include "elf/avr.h"
  97 #include "elf/bfin.h"
  98 #include "elf/cr16.h"
  99 #include "elf/cris.h"
 100 #include "elf/crx.h"
 101 #include "elf/csky.h"
 102 #include "elf/d10v.h"
 103 #include "elf/d30v.h"
 104 #include "elf/dlx.h"
 105 #include "elf/bpf.h"
 106 #include "elf/epiphany.h"
 107 #include "elf/fr30.h"
 108 #include "elf/frv.h"
 109 #include "elf/ft32.h"
 110 #include "elf/h8.h"
 111 #include "elf/hppa.h"
 112 #include "elf/i386.h"
 113 #include "elf/i370.h"
 114 #include "elf/i860.h"
 115 #include "elf/i960.h"
 116 #include "elf/ia64.h"
 117 #include "elf/ip2k.h"
 118 #include "elf/lm32.h"
 119 #include "elf/iq2000.h"
 120 #include "elf/m32c.h"
 121 #include "elf/m32r.h"
 122 #include "elf/m68k.h"
 123 #include "elf/m68hc11.h"
 124 #include "elf/s12z.h"
 125 #include "elf/mcore.h"
 126 #include "elf/mep.h"
 127 #include "elf/metag.h"
 128 #include "elf/microblaze.h"
 129 #include "elf/mips.h"
 130 #include "elf/mmix.h"
 131 #include "elf/mn10200.h"
 132 #include "elf/mn10300.h"
 133 #include "elf/moxie.h"
 134 #include "elf/mt.h"
 135 #include "elf/msp430.h"
 136 #include "elf/nds32.h"
 137 #include "elf/nfp.h"
 138 #include "elf/nios2.h"
 139 #include "elf/or1k.h"
 140 #include "elf/pj.h"
 141 #include "elf/ppc.h"
 142 #include "elf/ppc64.h"
 143 #include "elf/pru.h"
 144 #include "elf/riscv.h"
 145 #include "elf/rl78.h"
 146 #include "elf/rx.h"
 147 #include "elf/s390.h"
 148 #include "elf/score.h"
 149 #include "elf/sh.h"
 150 #include "elf/sparc.h"
 151 #include "elf/spu.h"
 152 #include "elf/tic6x.h"
 153 #include "elf/tilegx.h"
 154 #include "elf/tilepro.h"
 155 #include "elf/v850.h"
 156 #include "elf/vax.h"
 157 #include "elf/visium.h"
 158 #include "elf/wasm32.h"
 159 #include "elf/x86-64.h"
 160 #include "elf/xc16x.h"
 161 #include "elf/xgate.h"
 162 #include "elf/xstormy16.h"
 163 #include "elf/xtensa.h"
 164
 165 #include "getopt.h"
 166 #include "libiberty.h"
 167 #include "safe-ctype.h"
 168 #include "filenames.h"
 169
 170 #ifndef offsetof
 171 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
 172 #endif
 173
 174 typedef struct elf_section_list
 175 {
 176   Elf_Internal_Shdr *        hdr;
 177   struct elf_section_list *  next;
 178 } elf_section_list;
 179
 180 /* Flag bits indicating particular types of dump.  */
 181 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
 182 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
 183 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
 184 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
 185 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
 186
 187 typedef unsigned char dump_type;
 188
 189 /* A linked list of the section names for which dumps were requested.  */
 190 struct dump_list_entry
 191 {
 192   char *                    name;
 193   dump_type                 type;
 194   struct dump_list_entry *  next;
 195 };
 196
 197 typedef struct filedata
 198 {
 199   const char *         file_name;
 200   FILE *               handle;
 201   bfd_size_type        file_size;
 202   Elf_Internal_Ehdr    file_header;
 203   Elf_Internal_Shdr *  section_headers;
 204   Elf_Internal_Phdr *  program_headers;
 205   char *               string_table;
 206   unsigned long        string_table_length;
 207   /* A dynamic array of flags indicating for which sections a dump of
 208      some kind has been requested.  It is reset on a per-object file
 209      basis and then initialised from the cmdline_dump_sects array,
 210      the results of interpreting the -w switch, and the
 211      dump_sects_byname list.  */
 212   dump_type *          dump_sects;
 213   unsigned int         num_dump_sects;
 214 } Filedata;
 215
 216 char * program_name = "readelf";
 217
 218 static unsigned long archive_file_offset;
 219 static unsigned long archive_file_size;
 220 static unsigned long dynamic_addr;
 221 static bfd_size_type dynamic_size;
 222 static size_t dynamic_nent;
 223 static char * dynamic_strings;
 224 static unsigned long dynamic_strings_length;
 225 static unsigned long num_dynamic_syms;
 226 static Elf_Internal_Sym * dynamic_symbols;
 227 static Elf_Internal_Syminfo * dynamic_syminfo;
 228 static unsigned long dynamic_syminfo_offset;
 229 static unsigned int dynamic_syminfo_nent;
 230 static char program_interpreter[PATH_MAX];
 231 static bfd_vma dynamic_info[DT_ENCODING];
 232 static bfd_vma dynamic_info_DT_GNU_HASH;
 233 static bfd_vma version_info[16];
 234 static Elf_Internal_Dyn *  dynamic_section;
 235 static elf_section_list * symtab_shndx_list;
 236 static bfd_boolean show_name = FALSE;
 237 static bfd_boolean do_dynamic = FALSE;
 238 static bfd_boolean do_syms = FALSE;
 239 static bfd_boolean do_dyn_syms = FALSE;
 240 static bfd_boolean do_reloc = FALSE;
 241 static bfd_boolean do_sections = FALSE;
 242 static bfd_boolean do_section_groups = FALSE;
 243 static bfd_boolean do_section_details = FALSE;
 244 static bfd_boolean do_segments = FALSE;
 245 static bfd_boolean do_unwind = FALSE;
 246 static bfd_boolean do_using_dynamic = FALSE;
 247 static bfd_boolean do_header = FALSE;
 248 static bfd_boolean do_dump = FALSE;
 249 static bfd_boolean do_version = FALSE;
 250 static bfd_boolean do_histogram = FALSE;
 251 static bfd_boolean do_debugging = FALSE;
 252 static bfd_boolean do_arch = FALSE;
 253 static bfd_boolean do_notes = FALSE;
 254 static bfd_boolean do_archive_index = FALSE;
 255 static bfd_boolean is_32bit_elf = FALSE;
 256 static bfd_boolean decompress_dumps = FALSE;
 257
 258 struct group_list
 259 {
 260   struct group_list *  next;
 261   unsigned int         section_index;
 262 };
 263
 264 struct group
 265 {
 266   struct group_list *  root;
 267   unsigned int         group_index;
 268 };
 269
 270 static size_t           group_count;
 271 static struct group *   section_groups;
 272 static struct group **  section_headers_groups;
 273
 274 /* A dynamic array of flags indicating for which sections a dump
 275    has been requested via command line switches.  */
 276 static Filedata         cmdline;
 277
 278 static struct dump_list_entry * dump_sects_byname;
 279
 280 /* How to print a vma value.  */
 281 typedef enum print_mode
 282 {
 283   HEX,
 284   DEC,
 285   DEC_5,
 286   UNSIGNED,
 287   PREFIX_HEX,
 288   FULL_HEX,
 289   LONG_HEX
 290 }
 291 print_mode;
 292
 293 /* Versioned symbol info.  */
 294 enum versioned_symbol_info
 295 {
 296   symbol_undefined,
 297   symbol_hidden,
 298   symbol_public
 299 };
 300
 301 static const char * get_symbol_version_string
 302   (Filedata *, bfd_boolean, const char *, unsigned long, unsigned,
 303    Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
 304
 305 #define UNKNOWN -1
 306
 307 #define SECTION_NAME(X)                                         \
 308   ((X) == NULL ? _("<none>")                                    \
 309    : filedata->string_table == NULL ? _("<no-strings>")         \
 310    : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>")    \
 311   : filedata->string_table + (X)->sh_name))
 312
 313 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 314
 315 #define GET_ELF_SYMBOLS(file, section, sym_count)                       \
 316   (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count)      \
 317    : get_64bit_elf_symbols (file, section, sym_count))
 318
 319 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
 320 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 321    already been called and verified that the string exists.  */
 322 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
 323
 324 #define REMOVE_ARCH_BITS(ADDR)                  \
 325   do                                            \
 326     {                                           \
 327       if (filedata->file_header.e_machine == EM_ARM)    \
 328         (ADDR) &= ~1;                           \
 329     }                                           \
 330   while (0)
 331 \f
 332 /* Print a BFD_VMA to an internal buffer, for use in error messages.
 333    BFD_FMA_FMT can't be used in translated strings.  */
 334
 335 static const char *
 336 bfd_vmatoa (char *fmtch, bfd_vma value)
 337 {
 338   /* bfd_vmatoa is used more then once in a printf call for output.
 339      Cycle through an array of buffers.  */
 340   static int buf_pos = 0;
 341   static struct bfd_vmatoa_buf
 342   {
 343     char place[64];
 344   } buf[4];
 345   char *ret;
 346   char fmt[32];
 347
 348   ret = buf[buf_pos++].place;
 349   buf_pos %= ARRAY_SIZE (buf);
 350
 351   sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch);
 352   snprintf (ret, sizeof (buf[0].place), fmt, value);
 353   return ret;
 354 }
 355
 356 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
 357    OFFSET + the offset of the current archive member, if we are examining an
 358    archive.  Put the retrieved data into VAR, if it is not NULL.  Otherwise
 359    allocate a buffer using malloc and fill that.  In either case return the
 360    pointer to the start of the retrieved data or NULL if something went wrong.
 361    If something does go wrong and REASON is not NULL then emit an error
 362    message using REASON as part of the context.  */
 363
 364 static void *
 365 get_data (void *         var,
 366           Filedata *     filedata,
 367           unsigned long  offset,
 368           bfd_size_type  size,
 369           bfd_size_type  nmemb,
 370           const char *   reason)
 371 {
 372   void * mvar;
 373   bfd_size_type amt = size * nmemb;
 374
 375   if (size == 0 || nmemb == 0)
 376     return NULL;
 377
 378   /* If the size_t type is smaller than the bfd_size_type, eg because
 379      you are building a 32-bit tool on a 64-bit host, then make sure
 380      that when the sizes are cast to (size_t) no information is lost.  */
 381   if (sizeof (size_t) < sizeof (bfd_size_type)
 382       && (   (bfd_size_type) ((size_t) size) != size
 383           || (bfd_size_type) ((size_t) nmemb) != nmemb))
 384     {
 385       if (reason)
 386         error (_("Size truncation prevents reading %s"
 387                  " elements of size %s for %s\n"),
 388                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 389       return NULL;
 390     }
 391
 392   /* Check for size overflow.  */
 393   if (amt < nmemb)
 394     {
 395       if (reason)
 396         error (_("Size overflow prevents reading %s"
 397                  " elements of size %s for %s\n"),
 398                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 399       return NULL;
 400     }
 401
 402   /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
 403      attempting to allocate memory when the read is bound to fail.  */
 404   if (archive_file_offset > filedata->file_size
 405       || offset > filedata->file_size - archive_file_offset
 406       || amt > filedata->file_size - archive_file_offset - offset)
 407     {
 408       if (reason)
 409         error (_("Reading %s bytes extends past end of file for %s\n"),
 410                bfd_vmatoa ("u", amt), reason);
 411       return NULL;
 412     }
 413
 414   if (fseek (filedata->handle, archive_file_offset + offset, SEEK_SET))
 415     {
 416       if (reason)
 417         error (_("Unable to seek to 0x%lx for %s\n"),
 418                archive_file_offset + offset, reason);
 419       return NULL;
 420     }
 421
 422   mvar = var;
 423   if (mvar == NULL)
 424     {
 425       /* Check for overflow.  */
 426       if (nmemb < (~(bfd_size_type) 0 - 1) / size)
 427         /* + 1 so that we can '\0' terminate invalid string table sections.  */
 428         mvar = malloc ((size_t) amt + 1);
 429
 430       if (mvar == NULL)
 431         {
 432           if (reason)
 433             error (_("Out of memory allocating %s bytes for %s\n"),
 434                    bfd_vmatoa ("u", amt), reason);
 435           return NULL;
 436         }
 437
 438       ((char *) mvar)[amt] = '\0';
 439     }
 440
 441   if (fread (mvar, (size_t) size, (size_t) nmemb, filedata->handle) != nmemb)
 442     {
 443       if (reason)
 444         error (_("Unable to read in %s bytes of %s\n"),
 445                bfd_vmatoa ("u", amt), reason);
 446       if (mvar != var)
 447         free (mvar);
 448       return NULL;
 449     }
 450
 451   return mvar;
 452 }
 453
 454 /* Print a VMA value in the MODE specified.
 455    Returns the number of characters displayed.  */
 456
 457 static unsigned int
 458 print_vma (bfd_vma vma, print_mode mode)
 459 {
 460   unsigned int nc = 0;
 461
 462   switch (mode)
 463     {
 464     case FULL_HEX:
 465       nc = printf ("0x");
 466       /* Fall through.  */
 467     case LONG_HEX:
 468 #ifdef BFD64
 469       if (is_32bit_elf)
 470         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
 471 #endif
 472       printf_vma (vma);
 473       return nc + 16;
 474
 475     case DEC_5:
 476       if (vma <= 99999)
 477         return printf ("%5" BFD_VMA_FMT "d", vma);
 478       /* Fall through.  */
 479     case PREFIX_HEX:
 480       nc = printf ("0x");
 481       /* Fall through.  */
 482     case HEX:
 483       return nc + printf ("%" BFD_VMA_FMT "x", vma);
 484
 485     case DEC:
 486       return printf ("%" BFD_VMA_FMT "d", vma);
 487
 488     case UNSIGNED:
 489       return printf ("%" BFD_VMA_FMT "u", vma);
 490
 491     default:
 492       /* FIXME: Report unrecognised mode ?  */
 493       return 0;
 494     }
 495 }
 496
 497 /* Display a symbol on stdout.  Handles the display of control characters and
 498    multibye characters (assuming the host environment supports them).
 499
 500    Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
 501
 502    If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
 503    padding as necessary.
 504
 505    Returns the number of emitted characters.  */
 506
 507 static unsigned int
 508 print_symbol (signed int width, const char *symbol)
 509 {
 510   bfd_boolean extra_padding = FALSE;
 511   signed int num_printed = 0;
 512 #ifdef HAVE_MBSTATE_T
 513   mbstate_t state;
 514 #endif
 515   unsigned int width_remaining;
 516
 517   if (width < 0)
 518     {
 519       /* Keep the width positive.  This helps the code below.  */
 520       width = - width;
 521       extra_padding = TRUE;
 522     }
 523   else if (width == 0)
 524     return 0;
 525
 526   if (do_wide)
 527     /* Set the remaining width to a very large value.
 528        This simplifies the code below.  */
 529     width_remaining = INT_MAX;
 530   else
 531     width_remaining = width;
 532
 533 #ifdef HAVE_MBSTATE_T
 534   /* Initialise the multibyte conversion state.  */
 535   memset (& state, 0, sizeof (state));
 536 #endif
 537
 538   while (width_remaining)
 539     {
 540       size_t  n;
 541       const char c = *symbol++;
 542
 543       if (c == 0)
 544         break;
 545
 546       /* Do not print control characters directly as they can affect terminal
 547          settings.  Such characters usually appear in the names generated
 548          by the assembler for local labels.  */
 549       if (ISCNTRL (c))
 550         {
 551           if (width_remaining < 2)
 552             break;
 553
 554           printf ("^%c", c + 0x40);
 555           width_remaining -= 2;
 556           num_printed += 2;
 557         }
 558       else if (ISPRINT (c))
 559         {
 560           putchar (c);
 561           width_remaining --;
 562           num_printed ++;
 563         }
 564       else
 565         {
 566 #ifdef HAVE_MBSTATE_T
 567           wchar_t w;
 568 #endif
 569           /* Let printf do the hard work of displaying multibyte characters.  */
 570           printf ("%.1s", symbol - 1);
 571           width_remaining --;
 572           num_printed ++;
 573
 574 #ifdef HAVE_MBSTATE_T
 575           /* Try to find out how many bytes made up the character that was
 576              just printed.  Advance the symbol pointer past the bytes that
 577              were displayed.  */
 578           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 579 #else
 580           n = 1;
 581 #endif
 582           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 583             symbol += (n - 1);
 584         }
 585     }
 586
 587   if (extra_padding && num_printed < width)
 588     {
 589       /* Fill in the remaining spaces.  */
 590       printf ("%-*s", width - num_printed, " ");
 591       num_printed = width;
 592     }
 593
 594   return num_printed;
 595 }
 596
 597 /* Returns a pointer to a static buffer containing a printable version of
 598    the given section's name.  Like print_symbol, except that it does not try
 599    to print multibyte characters, it just interprets them as hex values.  */
 600
 601 static const char *
 602 printable_section_name (Filedata * filedata, const Elf_Internal_Shdr * sec)
 603 {
 604 #define MAX_PRINT_SEC_NAME_LEN 128
 605   static char  sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
 606   const char * name = SECTION_NAME (sec);
 607   char *       buf = sec_name_buf;
 608   char         c;
 609   unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
 610
 611   while ((c = * name ++) != 0)
 612     {
 613       if (ISCNTRL (c))
 614         {
 615           if (remaining < 2)
 616             break;
 617
 618           * buf ++ = '^';
 619           * buf ++ = c + 0x40;
 620           remaining -= 2;
 621         }
 622       else if (ISPRINT (c))
 623         {
 624           * buf ++ = c;
 625           remaining -= 1;
 626         }
 627       else
 628         {
 629           static char hex[17] = "0123456789ABCDEF";
 630
 631           if (remaining < 4)
 632             break;
 633           * buf ++ = '<';
 634           * buf ++ = hex[(c & 0xf0) >> 4];
 635           * buf ++ = hex[c & 0x0f];
 636           * buf ++ = '>';
 637           remaining -= 4;
 638         }
 639
 640       if (remaining == 0)
 641         break;
 642     }
 643
 644   * buf = 0;
 645   return sec_name_buf;
 646 }
 647
 648 static const char *
 649 printable_section_name_from_index (Filedata * filedata, unsigned long ndx)
 650 {
 651   if (ndx >= filedata->file_header.e_shnum)
 652     return _("<corrupt>");
 653
 654   return printable_section_name (filedata, filedata->section_headers + ndx);
 655 }
 656
 657 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 658
 659 static Elf_Internal_Shdr *
 660 find_section (Filedata * filedata, const char * name)
 661 {
 662   unsigned int i;
 663
 664   if (filedata->section_headers == NULL)
 665     return NULL;
 666
 667   for (i = 0; i < filedata->file_header.e_shnum; i++)
 668     if (streq (SECTION_NAME (filedata->section_headers + i), name))
 669       return filedata->section_headers + i;
 670
 671   return NULL;
 672 }
 673
 674 /* Return a pointer to a section containing ADDR, or NULL if no such
 675    section exists.  */
 676
 677 static Elf_Internal_Shdr *
 678 find_section_by_address (Filedata * filedata, bfd_vma addr)
 679 {
 680   unsigned int i;
 681
 682   if (filedata->section_headers == NULL)
 683     return NULL;
 684
 685   for (i = 0; i < filedata->file_header.e_shnum; i++)
 686     {
 687       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 688
 689       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 690         return sec;
 691     }
 692
 693   return NULL;
 694 }
 695
 696 static Elf_Internal_Shdr *
 697 find_section_by_type (Filedata * filedata, unsigned int type)
 698 {
 699   unsigned int i;
 700
 701   if (filedata->section_headers == NULL)
 702     return NULL;
 703
 704   for (i = 0; i < filedata->file_header.e_shnum; i++)
 705     {
 706       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 707
 708       if (sec->sh_type == type)
 709         return sec;
 710     }
 711
 712   return NULL;
 713 }
 714
 715 /* Return a pointer to section NAME, or NULL if no such section exists,
 716    restricted to the list of sections given in SET.  */
 717
 718 static Elf_Internal_Shdr *
 719 find_section_in_set (Filedata * filedata, const char * name, unsigned int * set)
 720 {
 721   unsigned int i;
 722
 723   if (filedata->section_headers == NULL)
 724     return NULL;
 725
 726   if (set != NULL)
 727     {
 728       while ((i = *set++) > 0)
 729         {
 730           /* See PR 21156 for a reproducer.  */
 731           if (i >= filedata->file_header.e_shnum)
 732             continue; /* FIXME: Should we issue an error message ?  */
 733
 734           if (streq (SECTION_NAME (filedata->section_headers + i), name))
 735             return filedata->section_headers + i;
 736         }
 737     }
 738
 739   return find_section (filedata, name);
 740 }
 741
 742 /* Read an unsigned LEB128 encoded value from DATA.
 743    Set *LENGTH_RETURN to the number of bytes read.  */
 744
 745 static inline unsigned long
 746 read_uleb128 (unsigned char * data,
 747               unsigned int * length_return,
 748               const unsigned char * const end)
 749 {
 750   return read_leb128 (data, length_return, FALSE, end);
 751 }
 752
 753 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
 754    This OS has so many departures from the ELF standard that we test it at
 755    many places.  */
 756
 757 static inline bfd_boolean
 758 is_ia64_vms (Filedata * filedata)
 759 {
 760   return filedata->file_header.e_machine == EM_IA_64
 761     && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 762 }
 763
 764 /* Guess the relocation size commonly used by the specific machines.  */
 765
 766 static bfd_boolean
 767 guess_is_rela (unsigned int e_machine)
 768 {
 769   switch (e_machine)
 770     {
 771       /* Targets that use REL relocations.  */
 772     case EM_386:
 773     case EM_IAMCU:
 774     case EM_960:
 775     case EM_ARM:
 776     case EM_D10V:
 777     case EM_CYGNUS_D10V:
 778     case EM_DLX:
 779     case EM_MIPS:
 780     case EM_MIPS_RS3_LE:
 781     case EM_CYGNUS_M32R:
 782     case EM_SCORE:
 783     case EM_XGATE:
 784     case EM_NFP:
 785     case EM_BPF:
 786       return FALSE;
 787
 788       /* Targets that use RELA relocations.  */
 789     case EM_68K:
 790     case EM_860:
 791     case EM_AARCH64:
 792     case EM_ADAPTEVA_EPIPHANY:
 793     case EM_ALPHA:
 794     case EM_ALTERA_NIOS2:
 795     case EM_ARC:
 796     case EM_ARC_COMPACT:
 797     case EM_ARC_COMPACT2:
 798     case EM_AVR:
 799     case EM_AVR_OLD:
 800     case EM_BLACKFIN:
 801     case EM_CR16:
 802     case EM_CRIS:
 803     case EM_CRX:
 804     case EM_CSKY:
 805     case EM_D30V:
 806     case EM_CYGNUS_D30V:
 807     case EM_FR30:
 808     case EM_FT32:
 809     case EM_CYGNUS_FR30:
 810     case EM_CYGNUS_FRV:
 811     case EM_H8S:
 812     case EM_H8_300:
 813     case EM_H8_300H:
 814     case EM_IA_64:
 815     case EM_IP2K:
 816     case EM_IP2K_OLD:
 817     case EM_IQ2000:
 818     case EM_LATTICEMICO32:
 819     case EM_M32C_OLD:
 820     case EM_M32C:
 821     case EM_M32R:
 822     case EM_MCORE:
 823     case EM_CYGNUS_MEP:
 824     case EM_METAG:
 825     case EM_MMIX:
 826     case EM_MN10200:
 827     case EM_CYGNUS_MN10200:
 828     case EM_MN10300:
 829     case EM_CYGNUS_MN10300:
 830     case EM_MOXIE:
 831     case EM_MSP430:
 832     case EM_MSP430_OLD:
 833     case EM_MT:
 834     case EM_NDS32:
 835     case EM_NIOS32:
 836     case EM_OR1K:
 837     case EM_PPC64:
 838     case EM_PPC:
 839     case EM_TI_PRU:
 840     case EM_RISCV:
 841     case EM_RL78:
 842     case EM_RX:
 843     case EM_S390:
 844     case EM_S390_OLD:
 845     case EM_SH:
 846     case EM_SPARC:
 847     case EM_SPARC32PLUS:
 848     case EM_SPARCV9:
 849     case EM_SPU:
 850     case EM_TI_C6000:
 851     case EM_TILEGX:
 852     case EM_TILEPRO:
 853     case EM_V800:
 854     case EM_V850:
 855     case EM_CYGNUS_V850:
 856     case EM_VAX:
 857     case EM_VISIUM:
 858     case EM_X86_64:
 859     case EM_L1OM:
 860     case EM_K1OM:
 861     case EM_XSTORMY16:
 862     case EM_XTENSA:
 863     case EM_XTENSA_OLD:
 864     case EM_MICROBLAZE:
 865     case EM_MICROBLAZE_OLD:
 866     case EM_WEBASSEMBLY:
 867       return TRUE;
 868
 869     case EM_68HC05:
 870     case EM_68HC08:
 871     case EM_68HC11:
 872     case EM_68HC16:
 873     case EM_FX66:
 874     case EM_ME16:
 875     case EM_MMA:
 876     case EM_NCPU:
 877     case EM_NDR1:
 878     case EM_PCP:
 879     case EM_ST100:
 880     case EM_ST19:
 881     case EM_ST7:
 882     case EM_ST9PLUS:
 883     case EM_STARCORE:
 884     case EM_SVX:
 885     case EM_TINYJ:
 886     default:
 887       warn (_("Don't know about relocations on this machine architecture\n"));
 888       return FALSE;
 889     }
 890 }
 891
 892 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 893    Returns TRUE upon success, FALSE otherwise.  If successful then a
 894    pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
 895    and the number of relocs loaded is placed in *NRELASP.  It is the caller's
 896    responsibility to free the allocated buffer.  */
 897
 898 static bfd_boolean
 899 slurp_rela_relocs (Filedata *            filedata,
 900                    unsigned long         rel_offset,
 901                    unsigned long         rel_size,
 902                    Elf_Internal_Rela **  relasp,
 903                    unsigned long *       nrelasp)
 904 {
 905   Elf_Internal_Rela * relas;
 906   size_t nrelas;
 907   unsigned int i;
 908
 909   if (is_32bit_elf)
 910     {
 911       Elf32_External_Rela * erelas;
 912
 913       erelas = (Elf32_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 914                                                  rel_size, _("32-bit relocation data"));
 915       if (!erelas)
 916         return FALSE;
 917
 918       nrelas = rel_size / sizeof (Elf32_External_Rela);
 919
 920       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 921                                              sizeof (Elf_Internal_Rela));
 922
 923       if (relas == NULL)
 924         {
 925           free (erelas);
 926           error (_("out of memory parsing relocs\n"));
 927           return FALSE;
 928         }
 929
 930       for (i = 0; i < nrelas; i++)
 931         {
 932           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 933           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 934           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 935         }
 936
 937       free (erelas);
 938     }
 939   else
 940     {
 941       Elf64_External_Rela * erelas;
 942
 943       erelas = (Elf64_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 944                                                  rel_size, _("64-bit relocation data"));
 945       if (!erelas)
 946         return FALSE;
 947
 948       nrelas = rel_size / sizeof (Elf64_External_Rela);
 949
 950       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 951                                              sizeof (Elf_Internal_Rela));
 952
 953       if (relas == NULL)
 954         {
 955           free (erelas);
 956           error (_("out of memory parsing relocs\n"));
 957           return FALSE;
 958         }
 959
 960       for (i = 0; i < nrelas; i++)
 961         {
 962           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 963           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 964           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 965
 966           /* The #ifdef BFD64 below is to prevent a compile time
 967              warning.  We know that if we do not have a 64 bit data
 968              type that we will never execute this code anyway.  */
 969 #ifdef BFD64
 970           if (filedata->file_header.e_machine == EM_MIPS
 971               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
 972             {
 973               /* In little-endian objects, r_info isn't really a
 974                  64-bit little-endian value: it has a 32-bit
 975                  little-endian symbol index followed by four
 976                  individual byte fields.  Reorder INFO
 977                  accordingly.  */
 978               bfd_vma inf = relas[i].r_info;
 979               inf = (((inf & 0xffffffff) << 32)
 980                       | ((inf >> 56) & 0xff)
 981                       | ((inf >> 40) & 0xff00)
 982                       | ((inf >> 24) & 0xff0000)
 983                       | ((inf >> 8) & 0xff000000));
 984               relas[i].r_info = inf;
 985             }
 986 #endif /* BFD64 */
 987         }
 988
 989       free (erelas);
 990     }
 991
 992   *relasp = relas;
 993   *nrelasp = nrelas;
 994   return TRUE;
 995 }
 996
 997 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 998    Returns TRUE upon success, FALSE otherwise.  If successful then a
 999    pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1000    and the number of relocs loaded is placed in *NRELSP.  It is the caller's
1001    responsibility to free the allocated buffer.  */
1002
1003 static bfd_boolean
1004 slurp_rel_relocs (Filedata *            filedata,
1005                   unsigned long         rel_offset,
1006                   unsigned long         rel_size,
1007                   Elf_Internal_Rela **  relsp,
1008                   unsigned long *       nrelsp)
1009 {
1010   Elf_Internal_Rela * rels;
1011   size_t nrels;
1012   unsigned int i;
1013
1014   if (is_32bit_elf)
1015     {
1016       Elf32_External_Rel * erels;
1017
1018       erels = (Elf32_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1019                                                rel_size, _("32-bit relocation data"));
1020       if (!erels)
1021         return FALSE;
1022
1023       nrels = rel_size / sizeof (Elf32_External_Rel);
1024
1025       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1026
1027       if (rels == NULL)
1028         {
1029           free (erels);
1030           error (_("out of memory parsing relocs\n"));
1031           return FALSE;
1032         }
1033
1034       for (i = 0; i < nrels; i++)
1035         {
1036           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1037           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1038           rels[i].r_addend = 0;
1039         }
1040
1041       free (erels);
1042     }
1043   else
1044     {
1045       Elf64_External_Rel * erels;
1046
1047       erels = (Elf64_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1048                                                rel_size, _("64-bit relocation data"));
1049       if (!erels)
1050         return FALSE;
1051
1052       nrels = rel_size / sizeof (Elf64_External_Rel);
1053
1054       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1055
1056       if (rels == NULL)
1057         {
1058           free (erels);
1059           error (_("out of memory parsing relocs\n"));
1060           return FALSE;
1061         }
1062
1063       for (i = 0; i < nrels; i++)
1064         {
1065           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1066           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1067           rels[i].r_addend = 0;
1068
1069           /* The #ifdef BFD64 below is to prevent a compile time
1070              warning.  We know that if we do not have a 64 bit data
1071              type that we will never execute this code anyway.  */
1072 #ifdef BFD64
1073           if (filedata->file_header.e_machine == EM_MIPS
1074               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
1075             {
1076               /* In little-endian objects, r_info isn't really a
1077                  64-bit little-endian value: it has a 32-bit
1078                  little-endian symbol index followed by four
1079                  individual byte fields.  Reorder INFO
1080                  accordingly.  */
1081               bfd_vma inf = rels[i].r_info;
1082               inf = (((inf & 0xffffffff) << 32)
1083                      | ((inf >> 56) & 0xff)
1084                      | ((inf >> 40) & 0xff00)
1085                      | ((inf >> 24) & 0xff0000)
1086                      | ((inf >> 8) & 0xff000000));
1087               rels[i].r_info = inf;
1088             }
1089 #endif /* BFD64 */
1090         }
1091
1092       free (erels);
1093     }
1094
1095   *relsp = rels;
1096   *nrelsp = nrels;
1097   return TRUE;
1098 }
1099
1100 /* Returns the reloc type extracted from the reloc info field.  */
1101
1102 static unsigned int
1103 get_reloc_type (Filedata * filedata, bfd_vma reloc_info)
1104 {
1105   if (is_32bit_elf)
1106     return ELF32_R_TYPE (reloc_info);
1107
1108   switch (filedata->file_header.e_machine)
1109     {
1110     case EM_MIPS:
1111       /* Note: We assume that reloc_info has already been adjusted for us.  */
1112       return ELF64_MIPS_R_TYPE (reloc_info);
1113
1114     case EM_SPARCV9:
1115       return ELF64_R_TYPE_ID (reloc_info);
1116
1117     default:
1118       return ELF64_R_TYPE (reloc_info);
1119     }
1120 }
1121
1122 /* Return the symbol index extracted from the reloc info field.  */
1123
1124 static bfd_vma
1125 get_reloc_symindex (bfd_vma reloc_info)
1126 {
1127   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1128 }
1129
1130 static inline bfd_boolean
1131 uses_msp430x_relocs (Filedata * filedata)
1132 {
1133   return
1134     filedata->file_header.e_machine == EM_MSP430 /* Paranoia.  */
1135     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
1136     && (((filedata->file_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1137         /* TI compiler uses ELFOSABI_NONE.  */
1138         || (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1139 }
1140
1141 /* Display the contents of the relocation data found at the specified
1142    offset.  */
1143
1144 static bfd_boolean
1145 dump_relocations (Filedata *          filedata,
1146                   unsigned long       rel_offset,
1147                   unsigned long       rel_size,
1148                   Elf_Internal_Sym *  symtab,
1149                   unsigned long       nsyms,
1150                   char *              strtab,
1151                   unsigned long       strtablen,
1152                   int                 is_rela,
1153                   bfd_boolean         is_dynsym)
1154 {
1155   unsigned long i;
1156   Elf_Internal_Rela * rels;
1157   bfd_boolean res = TRUE;
1158
1159   if (is_rela == UNKNOWN)
1160     is_rela = guess_is_rela (filedata->file_header.e_machine);
1161
1162   if (is_rela)
1163     {
1164       if (!slurp_rela_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1165         return FALSE;
1166     }
1167   else
1168     {
1169       if (!slurp_rel_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1170         return FALSE;
1171     }
1172
1173   if (is_32bit_elf)
1174     {
1175       if (is_rela)
1176         {
1177           if (do_wide)
1178             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
1179           else
1180             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
1181         }
1182       else
1183         {
1184           if (do_wide)
1185             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
1186           else
1187             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
1188         }
1189     }
1190   else
1191     {
1192       if (is_rela)
1193         {
1194           if (do_wide)
1195             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
1196           else
1197             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
1198         }
1199       else
1200         {
1201           if (do_wide)
1202             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
1203           else
1204             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
1205         }
1206     }
1207
1208   for (i = 0; i < rel_size; i++)
1209     {
1210       const char * rtype;
1211       bfd_vma offset;
1212       bfd_vma inf;
1213       bfd_vma symtab_index;
1214       bfd_vma type;
1215
1216       offset = rels[i].r_offset;
1217       inf    = rels[i].r_info;
1218
1219       type = get_reloc_type (filedata, inf);
1220       symtab_index = get_reloc_symindex  (inf);
1221
1222       if (is_32bit_elf)
1223         {
1224           printf ("%8.8lx  %8.8lx ",
1225                   (unsigned long) offset & 0xffffffff,
1226                   (unsigned long) inf & 0xffffffff);
1227         }
1228       else
1229         {
1230 #if BFD_HOST_64BIT_LONG
1231           printf (do_wide
1232                   ? "%16.16lx  %16.16lx "
1233                   : "%12.12lx  %12.12lx ",
1234                   offset, inf);
1235 #elif BFD_HOST_64BIT_LONG_LONG
1236 #ifndef __MSVCRT__
1237           printf (do_wide
1238                   ? "%16.16llx  %16.16llx "
1239                   : "%12.12llx  %12.12llx ",
1240                   offset, inf);
1241 #else
1242           printf (do_wide
1243                   ? "%16.16I64x  %16.16I64x "
1244                   : "%12.12I64x  %12.12I64x ",
1245                   offset, inf);
1246 #endif
1247 #else
1248           printf (do_wide
1249                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1250                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1251                   _bfd_int64_high (offset),
1252                   _bfd_int64_low (offset),
1253                   _bfd_int64_high (inf),
1254                   _bfd_int64_low (inf));
1255 #endif
1256         }
1257
1258       switch (filedata->file_header.e_machine)
1259         {
1260         default:
1261           rtype = NULL;
1262           break;
1263
1264         case EM_AARCH64:
1265           rtype = elf_aarch64_reloc_type (type);
1266           break;
1267
1268         case EM_M32R:
1269         case EM_CYGNUS_M32R:
1270           rtype = elf_m32r_reloc_type (type);
1271           break;
1272
1273         case EM_386:
1274         case EM_IAMCU:
1275           rtype = elf_i386_reloc_type (type);
1276           break;
1277
1278         case EM_68HC11:
1279         case EM_68HC12:
1280           rtype = elf_m68hc11_reloc_type (type);
1281           break;
1282
1283         case EM_S12Z:
1284           rtype = elf_s12z_reloc_type (type);
1285           break;
1286
1287         case EM_68K:
1288           rtype = elf_m68k_reloc_type (type);
1289           break;
1290
1291         case EM_960:
1292           rtype = elf_i960_reloc_type (type);
1293           break;
1294
1295         case EM_AVR:
1296         case EM_AVR_OLD:
1297           rtype = elf_avr_reloc_type (type);
1298           break;
1299
1300         case EM_OLD_SPARCV9:
1301         case EM_SPARC32PLUS:
1302         case EM_SPARCV9:
1303         case EM_SPARC:
1304           rtype = elf_sparc_reloc_type (type);
1305           break;
1306
1307         case EM_SPU:
1308           rtype = elf_spu_reloc_type (type);
1309           break;
1310
1311         case EM_V800:
1312           rtype = v800_reloc_type (type);
1313           break;
1314         case EM_V850:
1315         case EM_CYGNUS_V850:
1316           rtype = v850_reloc_type (type);
1317           break;
1318
1319         case EM_D10V:
1320         case EM_CYGNUS_D10V:
1321           rtype = elf_d10v_reloc_type (type);
1322           break;
1323
1324         case EM_D30V:
1325         case EM_CYGNUS_D30V:
1326           rtype = elf_d30v_reloc_type (type);
1327           break;
1328
1329         case EM_DLX:
1330           rtype = elf_dlx_reloc_type (type);
1331           break;
1332
1333         case EM_SH:
1334           rtype = elf_sh_reloc_type (type);
1335           break;
1336
1337         case EM_MN10300:
1338         case EM_CYGNUS_MN10300:
1339           rtype = elf_mn10300_reloc_type (type);
1340           break;
1341
1342         case EM_MN10200:
1343         case EM_CYGNUS_MN10200:
1344           rtype = elf_mn10200_reloc_type (type);
1345           break;
1346
1347         case EM_FR30:
1348         case EM_CYGNUS_FR30:
1349           rtype = elf_fr30_reloc_type (type);
1350           break;
1351
1352         case EM_CYGNUS_FRV:
1353           rtype = elf_frv_reloc_type (type);
1354           break;
1355
1356         case EM_CSKY:
1357           rtype = elf_csky_reloc_type (type);
1358           break;
1359
1360         case EM_FT32:
1361           rtype = elf_ft32_reloc_type (type);
1362           break;
1363
1364         case EM_MCORE:
1365           rtype = elf_mcore_reloc_type (type);
1366           break;
1367
1368         case EM_MMIX:
1369           rtype = elf_mmix_reloc_type (type);
1370           break;
1371
1372         case EM_MOXIE:
1373           rtype = elf_moxie_reloc_type (type);
1374           break;
1375
1376         case EM_MSP430:
1377           if (uses_msp430x_relocs (filedata))
1378             {
1379               rtype = elf_msp430x_reloc_type (type);
1380               break;
1381             }
1382           /* Fall through.  */
1383         case EM_MSP430_OLD:
1384           rtype = elf_msp430_reloc_type (type);
1385           break;
1386
1387         case EM_NDS32:
1388           rtype = elf_nds32_reloc_type (type);
1389           break;
1390
1391         case EM_PPC:
1392           rtype = elf_ppc_reloc_type (type);
1393           break;
1394
1395         case EM_PPC64:
1396           rtype = elf_ppc64_reloc_type (type);
1397           break;
1398
1399         case EM_MIPS:
1400         case EM_MIPS_RS3_LE:
1401           rtype = elf_mips_reloc_type (type);
1402           break;
1403
1404         case EM_RISCV:
1405           rtype = elf_riscv_reloc_type (type);
1406           break;
1407
1408         case EM_ALPHA:
1409           rtype = elf_alpha_reloc_type (type);
1410           break;
1411
1412         case EM_ARM:
1413           rtype = elf_arm_reloc_type (type);
1414           break;
1415
1416         case EM_ARC:
1417         case EM_ARC_COMPACT:
1418         case EM_ARC_COMPACT2:
1419           rtype = elf_arc_reloc_type (type);
1420           break;
1421
1422         case EM_PARISC:
1423           rtype = elf_hppa_reloc_type (type);
1424           break;
1425
1426         case EM_H8_300:
1427         case EM_H8_300H:
1428         case EM_H8S:
1429           rtype = elf_h8_reloc_type (type);
1430           break;
1431
1432         case EM_OR1K:
1433           rtype = elf_or1k_reloc_type (type);
1434           break;
1435
1436         case EM_PJ:
1437         case EM_PJ_OLD:
1438           rtype = elf_pj_reloc_type (type);
1439           break;
1440         case EM_IA_64:
1441           rtype = elf_ia64_reloc_type (type);
1442           break;
1443
1444         case EM_CRIS:
1445           rtype = elf_cris_reloc_type (type);
1446           break;
1447
1448         case EM_860:
1449           rtype = elf_i860_reloc_type (type);
1450           break;
1451
1452         case EM_X86_64:
1453         case EM_L1OM:
1454         case EM_K1OM:
1455           rtype = elf_x86_64_reloc_type (type);
1456           break;
1457
1458         case EM_S370:
1459           rtype = i370_reloc_type (type);
1460           break;
1461
1462         case EM_S390_OLD:
1463         case EM_S390:
1464           rtype = elf_s390_reloc_type (type);
1465           break;
1466
1467         case EM_SCORE:
1468           rtype = elf_score_reloc_type (type);
1469           break;
1470
1471         case EM_XSTORMY16:
1472           rtype = elf_xstormy16_reloc_type (type);
1473           break;
1474
1475         case EM_CRX:
1476           rtype = elf_crx_reloc_type (type);
1477           break;
1478
1479         case EM_VAX:
1480           rtype = elf_vax_reloc_type (type);
1481           break;
1482
1483         case EM_VISIUM:
1484           rtype = elf_visium_reloc_type (type);
1485           break;
1486
1487         case EM_BPF:
1488           rtype = elf_bpf_reloc_type (type);
1489           break;
1490
1491         case EM_ADAPTEVA_EPIPHANY:
1492           rtype = elf_epiphany_reloc_type (type);
1493           break;
1494
1495         case EM_IP2K:
1496         case EM_IP2K_OLD:
1497           rtype = elf_ip2k_reloc_type (type);
1498           break;
1499
1500         case EM_IQ2000:
1501           rtype = elf_iq2000_reloc_type (type);
1502           break;
1503
1504         case EM_XTENSA_OLD:
1505         case EM_XTENSA:
1506           rtype = elf_xtensa_reloc_type (type);
1507           break;
1508
1509         case EM_LATTICEMICO32:
1510           rtype = elf_lm32_reloc_type (type);
1511           break;
1512
1513         case EM_M32C_OLD:
1514         case EM_M32C:
1515           rtype = elf_m32c_reloc_type (type);
1516           break;
1517
1518         case EM_MT:
1519           rtype = elf_mt_reloc_type (type);
1520           break;
1521
1522         case EM_BLACKFIN:
1523           rtype = elf_bfin_reloc_type (type);
1524           break;
1525
1526         case EM_CYGNUS_MEP:
1527           rtype = elf_mep_reloc_type (type);
1528           break;
1529
1530         case EM_CR16:
1531           rtype = elf_cr16_reloc_type (type);
1532           break;
1533
1534         case EM_MICROBLAZE:
1535         case EM_MICROBLAZE_OLD:
1536           rtype = elf_microblaze_reloc_type (type);
1537           break;
1538
1539         case EM_RL78:
1540           rtype = elf_rl78_reloc_type (type);
1541           break;
1542
1543         case EM_RX:
1544           rtype = elf_rx_reloc_type (type);
1545           break;
1546
1547         case EM_METAG:
1548           rtype = elf_metag_reloc_type (type);
1549           break;
1550
1551         case EM_XC16X:
1552         case EM_C166:
1553           rtype = elf_xc16x_reloc_type (type);
1554           break;
1555
1556         case EM_TI_C6000:
1557           rtype = elf_tic6x_reloc_type (type);
1558           break;
1559
1560         case EM_TILEGX:
1561           rtype = elf_tilegx_reloc_type (type);
1562           break;
1563
1564         case EM_TILEPRO:
1565           rtype = elf_tilepro_reloc_type (type);
1566           break;
1567
1568         case EM_WEBASSEMBLY:
1569           rtype = elf_wasm32_reloc_type (type);
1570           break;
1571
1572         case EM_XGATE:
1573           rtype = elf_xgate_reloc_type (type);
1574           break;
1575
1576         case EM_ALTERA_NIOS2:
1577           rtype = elf_nios2_reloc_type (type);
1578           break;
1579
1580         case EM_TI_PRU:
1581           rtype = elf_pru_reloc_type (type);
1582           break;
1583
1584         case EM_NFP:
1585           if (EF_NFP_MACH (filedata->file_header.e_flags) == E_NFP_MACH_3200)
1586             rtype = elf_nfp3200_reloc_type (type);
1587           else
1588             rtype = elf_nfp_reloc_type (type);
1589           break;
1590         }
1591
1592       if (rtype == NULL)
1593         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1594       else
1595         printf (do_wide ? "%-22s" : "%-17.17s", rtype);
1596
1597       if (filedata->file_header.e_machine == EM_ALPHA
1598           && rtype != NULL
1599           && streq (rtype, "R_ALPHA_LITUSE")
1600           && is_rela)
1601         {
1602           switch (rels[i].r_addend)
1603             {
1604             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1605             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1606             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1607             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1608             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1609             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1610             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1611             default: rtype = NULL;
1612             }
1613
1614           if (rtype)
1615             printf (" (%s)", rtype);
1616           else
1617             {
1618               putchar (' ');
1619               printf (_("<unknown addend: %lx>"),
1620                       (unsigned long) rels[i].r_addend);
1621               res = FALSE;
1622             }
1623         }
1624       else if (symtab_index)
1625         {
1626           if (symtab == NULL || symtab_index >= nsyms)
1627             {
1628               error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1629               res = FALSE;
1630             }
1631           else
1632             {
1633               Elf_Internal_Sym * psym;
1634               const char * version_string;
1635               enum versioned_symbol_info sym_info;
1636               unsigned short vna_other;
1637
1638               psym = symtab + symtab_index;
1639
1640               version_string
1641                 = get_symbol_version_string (filedata, is_dynsym,
1642                                              strtab, strtablen,
1643                                              symtab_index,
1644                                              psym,
1645                                              &sym_info,
1646                                              &vna_other);
1647
1648               printf (" ");
1649
1650               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1651                 {
1652                   const char * name;
1653                   unsigned int len;
1654                   unsigned int width = is_32bit_elf ? 8 : 14;
1655
1656                   /* Relocations against GNU_IFUNC symbols do not use the value
1657                      of the symbol as the address to relocate against.  Instead
1658                      they invoke the function named by the symbol and use its
1659                      result as the address for relocation.
1660
1661                      To indicate this to the user, do not display the value of
1662                      the symbol in the "Symbols's Value" field.  Instead show
1663                      its name followed by () as a hint that the symbol is
1664                      invoked.  */
1665
1666                   if (strtab == NULL
1667                       || psym->st_name == 0
1668                       || psym->st_name >= strtablen)
1669                     name = "??";
1670                   else
1671                     name = strtab + psym->st_name;
1672
1673                   len = print_symbol (width, name);
1674                   if (version_string)
1675                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1676                             version_string);
1677                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1678                 }
1679               else
1680                 {
1681                   print_vma (psym->st_value, LONG_HEX);
1682
1683                   printf (is_32bit_elf ? "   " : " ");
1684                 }
1685
1686               if (psym->st_name == 0)
1687                 {
1688                   const char * sec_name = "<null>";
1689                   char name_buf[40];
1690
1691                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1692                     {
1693                       if (psym->st_shndx < filedata->file_header.e_shnum)
1694                         sec_name = SECTION_NAME (filedata->section_headers + psym->st_shndx);
1695                       else if (psym->st_shndx == SHN_ABS)
1696                         sec_name = "ABS";
1697                       else if (psym->st_shndx == SHN_COMMON)
1698                         sec_name = "COMMON";
1699                       else if ((filedata->file_header.e_machine == EM_MIPS
1700                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1701                                || (filedata->file_header.e_machine == EM_TI_C6000
1702                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1703                         sec_name = "SCOMMON";
1704                       else if (filedata->file_header.e_machine == EM_MIPS
1705                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1706                         sec_name = "SUNDEF";
1707                       else if ((filedata->file_header.e_machine == EM_X86_64
1708                                 || filedata->file_header.e_machine == EM_L1OM
1709                                 || filedata->file_header.e_machine == EM_K1OM)
1710                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1711                         sec_name = "LARGE_COMMON";
1712                       else if (filedata->file_header.e_machine == EM_IA_64
1713                                && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1714                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1715                         sec_name = "ANSI_COM";
1716                       else if (is_ia64_vms (filedata)
1717                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1718                         sec_name = "VMS_SYMVEC";
1719                       else
1720                         {
1721                           sprintf (name_buf, "<section 0x%x>",
1722                                    (unsigned int) psym->st_shndx);
1723                           sec_name = name_buf;
1724                         }
1725                     }
1726                   print_symbol (22, sec_name);
1727                 }
1728               else if (strtab == NULL)
1729                 printf (_("<string table index: %3ld>"), psym->st_name);
1730               else if (psym->st_name >= strtablen)
1731                 {
1732                   error (_("<corrupt string table index: %3ld>"), psym->st_name);
1733                   res = FALSE;
1734                 }
1735               else
1736                 {
1737                   print_symbol (22, strtab + psym->st_name);
1738                   if (version_string)
1739                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1740                             version_string);
1741                 }
1742
1743               if (is_rela)
1744                 {
1745                   bfd_vma off = rels[i].r_addend;
1746
1747                   if ((bfd_signed_vma) off < 0)
1748                     printf (" - %" BFD_VMA_FMT "x", - off);
1749                   else
1750                     printf (" + %" BFD_VMA_FMT "x", off);
1751                 }
1752             }
1753         }
1754       else if (is_rela)
1755         {
1756           bfd_vma off = rels[i].r_addend;
1757
1758           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1759           if ((bfd_signed_vma) off < 0)
1760             printf ("-%" BFD_VMA_FMT "x", - off);
1761           else
1762             printf ("%" BFD_VMA_FMT "x", off);
1763         }
1764
1765       if (filedata->file_header.e_machine == EM_SPARCV9
1766           && rtype != NULL
1767           && streq (rtype, "R_SPARC_OLO10"))
1768         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1769
1770       putchar ('\n');
1771
1772 #ifdef BFD64
1773       if (! is_32bit_elf && filedata->file_header.e_machine == EM_MIPS)
1774         {
1775           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1776           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1777           const char * rtype2 = elf_mips_reloc_type (type2);
1778           const char * rtype3 = elf_mips_reloc_type (type3);
1779
1780           printf ("                    Type2: ");
1781
1782           if (rtype2 == NULL)
1783             printf (_("unrecognized: %-7lx"),
1784                     (unsigned long) type2 & 0xffffffff);
1785           else
1786             printf ("%-17.17s", rtype2);
1787
1788           printf ("\n                    Type3: ");
1789
1790           if (rtype3 == NULL)
1791             printf (_("unrecognized: %-7lx"),
1792                     (unsigned long) type3 & 0xffffffff);
1793           else
1794             printf ("%-17.17s", rtype3);
1795
1796           putchar ('\n');
1797         }
1798 #endif /* BFD64 */
1799     }
1800
1801   free (rels);
1802
1803   return res;
1804 }
1805
1806 static const char *
1807 get_aarch64_dynamic_type (unsigned long type)
1808 {
1809   switch (type)
1810     {
1811     case DT_AARCH64_BTI_PLT:  return "AARCH64_BTI_PLT";
1812     case DT_AARCH64_PAC_PLT:  return "AARCH64_PAC_PLT";
1813     case DT_AARCH64_VARIANT_PCS:  return "AARCH64_VARIANT_PCS";
1814     default:
1815       return NULL;
1816     }
1817 }
1818
1819 static const char *
1820 get_mips_dynamic_type (unsigned long type)
1821 {
1822   switch (type)
1823     {
1824     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1825     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1826     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1827     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1828     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1829     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1830     case DT_MIPS_MSYM: return "MIPS_MSYM";
1831     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1832     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1833     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1834     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1835     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1836     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1837     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1838     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1839     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1840     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1841     case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1842     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1843     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1844     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1845     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1846     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1847     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1848     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1849     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1850     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1851     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1852     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1853     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1854     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1855     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1856     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1857     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1858     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1859     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1860     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1861     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1862     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1863     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1864     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1865     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1866     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1867     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1868     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1869     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1870     default:
1871       return NULL;
1872     }
1873 }
1874
1875 static const char *
1876 get_sparc64_dynamic_type (unsigned long type)
1877 {
1878   switch (type)
1879     {
1880     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1881     default:
1882       return NULL;
1883     }
1884 }
1885
1886 static const char *
1887 get_ppc_dynamic_type (unsigned long type)
1888 {
1889   switch (type)
1890     {
1891     case DT_PPC_GOT:    return "PPC_GOT";
1892     case DT_PPC_OPT:    return "PPC_OPT";
1893     default:
1894       return NULL;
1895     }
1896 }
1897
1898 static const char *
1899 get_ppc64_dynamic_type (unsigned long type)
1900 {
1901   switch (type)
1902     {
1903     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1904     case DT_PPC64_OPD:    return "PPC64_OPD";
1905     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1906     case DT_PPC64_OPT:    return "PPC64_OPT";
1907     default:
1908       return NULL;
1909     }
1910 }
1911
1912 static const char *
1913 get_parisc_dynamic_type (unsigned long type)
1914 {
1915   switch (type)
1916     {
1917     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1918     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1919     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1920     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1921     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1922     case DT_HP_PREINIT:         return "HP_PREINIT";
1923     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1924     case DT_HP_NEEDED:          return "HP_NEEDED";
1925     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1926     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1927     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1928     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1929     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1930     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1931     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1932     case DT_HP_FILTERED:        return "HP_FILTERED";
1933     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1934     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1935     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1936     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1937     case DT_PLT:                return "PLT";
1938     case DT_PLT_SIZE:           return "PLT_SIZE";
1939     case DT_DLT:                return "DLT";
1940     case DT_DLT_SIZE:           return "DLT_SIZE";
1941     default:
1942       return NULL;
1943     }
1944 }
1945
1946 static const char *
1947 get_ia64_dynamic_type (unsigned long type)
1948 {
1949   switch (type)
1950     {
1951     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1952     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1953     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1954     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1955     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1956     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1957     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1958     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1959     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1960     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1961     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1962     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1963     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1964     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1965     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1966     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1967     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1968     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1969     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1970     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1971     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1972     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1973     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1974     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1975     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1976     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1977     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1978     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1979     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1980     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1981     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1982     default:
1983       return NULL;
1984     }
1985 }
1986
1987 static const char *
1988 get_solaris_section_type (unsigned long type)
1989 {
1990   switch (type)
1991     {
1992     case 0x6fffffee: return "SUNW_ancillary";
1993     case 0x6fffffef: return "SUNW_capchain";
1994     case 0x6ffffff0: return "SUNW_capinfo";
1995     case 0x6ffffff1: return "SUNW_symsort";
1996     case 0x6ffffff2: return "SUNW_tlssort";
1997     case 0x6ffffff3: return "SUNW_LDYNSYM";
1998     case 0x6ffffff4: return "SUNW_dof";
1999     case 0x6ffffff5: return "SUNW_cap";
2000     case 0x6ffffff6: return "SUNW_SIGNATURE";
2001     case 0x6ffffff7: return "SUNW_ANNOTATE";
2002     case 0x6ffffff8: return "SUNW_DEBUGSTR";
2003     case 0x6ffffff9: return "SUNW_DEBUG";
2004     case 0x6ffffffa: return "SUNW_move";
2005     case 0x6ffffffb: return "SUNW_COMDAT";
2006     case 0x6ffffffc: return "SUNW_syminfo";
2007     case 0x6ffffffd: return "SUNW_verdef";
2008     case 0x6ffffffe: return "SUNW_verneed";
2009     case 0x6fffffff: return "SUNW_versym";
2010     case 0x70000000: return "SPARC_GOTDATA";
2011     default: return NULL;
2012     }
2013 }
2014
2015 static const char *
2016 get_alpha_dynamic_type (unsigned long type)
2017 {
2018   switch (type)
2019     {
2020     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
2021     default: return NULL;
2022     }
2023 }
2024
2025 static const char *
2026 get_score_dynamic_type (unsigned long type)
2027 {
2028   switch (type)
2029     {
2030     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
2031     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
2032     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
2033     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
2034     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
2035     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
2036     default:                    return NULL;
2037     }
2038 }
2039
2040 static const char *
2041 get_tic6x_dynamic_type (unsigned long type)
2042 {
2043   switch (type)
2044     {
2045     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
2046     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
2047     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
2048     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
2049     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
2050     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
2051     default:                   return NULL;
2052     }
2053 }
2054
2055 static const char *
2056 get_nios2_dynamic_type (unsigned long type)
2057 {
2058   switch (type)
2059     {
2060     case DT_NIOS2_GP: return "NIOS2_GP";
2061     default:          return NULL;
2062     }
2063 }
2064
2065 static const char *
2066 get_solaris_dynamic_type (unsigned long type)
2067 {
2068   switch (type)
2069     {
2070     case 0x6000000d: return "SUNW_AUXILIARY";
2071     case 0x6000000e: return "SUNW_RTLDINF";
2072     case 0x6000000f: return "SUNW_FILTER";
2073     case 0x60000010: return "SUNW_CAP";
2074     case 0x60000011: return "SUNW_SYMTAB";
2075     case 0x60000012: return "SUNW_SYMSZ";
2076     case 0x60000013: return "SUNW_SORTENT";
2077     case 0x60000014: return "SUNW_SYMSORT";
2078     case 0x60000015: return "SUNW_SYMSORTSZ";
2079     case 0x60000016: return "SUNW_TLSSORT";
2080     case 0x60000017: return "SUNW_TLSSORTSZ";
2081     case 0x60000018: return "SUNW_CAPINFO";
2082     case 0x60000019: return "SUNW_STRPAD";
2083     case 0x6000001a: return "SUNW_CAPCHAIN";
2084     case 0x6000001b: return "SUNW_LDMACH";
2085     case 0x6000001d: return "SUNW_CAPCHAINENT";
2086     case 0x6000001f: return "SUNW_CAPCHAINSZ";
2087     case 0x60000021: return "SUNW_PARENT";
2088     case 0x60000023: return "SUNW_ASLR";
2089     case 0x60000025: return "SUNW_RELAX";
2090     case 0x60000029: return "SUNW_NXHEAP";
2091     case 0x6000002b: return "SUNW_NXSTACK";
2092
2093     case 0x70000001: return "SPARC_REGISTER";
2094     case 0x7ffffffd: return "AUXILIARY";
2095     case 0x7ffffffe: return "USED";
2096     case 0x7fffffff: return "FILTER";
2097
2098     default: return NULL;
2099     }
2100 }
2101
2102 static const char *
2103 get_dynamic_type (Filedata * filedata, unsigned long type)
2104 {
2105   static char buff[64];
2106
2107   switch (type)
2108     {
2109     case DT_NULL:       return "NULL";
2110     case DT_NEEDED:     return "NEEDED";
2111     case DT_PLTRELSZ:   return "PLTRELSZ";
2112     case DT_PLTGOT:     return "PLTGOT";
2113     case DT_HASH:       return "HASH";
2114     case DT_STRTAB:     return "STRTAB";
2115     case DT_SYMTAB:     return "SYMTAB";
2116     case DT_RELA:       return "RELA";
2117     case DT_RELASZ:     return "RELASZ";
2118     case DT_RELAENT:    return "RELAENT";
2119     case DT_STRSZ:      return "STRSZ";
2120     case DT_SYMENT:     return "SYMENT";
2121     case DT_INIT:       return "INIT";
2122     case DT_FINI:       return "FINI";
2123     case DT_SONAME:     return "SONAME";
2124     case DT_RPATH:      return "RPATH";
2125     case DT_SYMBOLIC:   return "SYMBOLIC";
2126     case DT_REL:        return "REL";
2127     case DT_RELSZ:      return "RELSZ";
2128     case DT_RELENT:     return "RELENT";
2129     case DT_PLTREL:     return "PLTREL";
2130     case DT_DEBUG:      return "DEBUG";
2131     case DT_TEXTREL:    return "TEXTREL";
2132     case DT_JMPREL:     return "JMPREL";
2133     case DT_BIND_NOW:   return "BIND_NOW";
2134     case DT_INIT_ARRAY: return "INIT_ARRAY";
2135     case DT_FINI_ARRAY: return "FINI_ARRAY";
2136     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2137     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2138     case DT_RUNPATH:    return "RUNPATH";
2139     case DT_FLAGS:      return "FLAGS";
2140
2141     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2142     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2143     case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2144
2145     case DT_CHECKSUM:   return "CHECKSUM";
2146     case DT_PLTPADSZ:   return "PLTPADSZ";
2147     case DT_MOVEENT:    return "MOVEENT";
2148     case DT_MOVESZ:     return "MOVESZ";
2149     case DT_FEATURE:    return "FEATURE";
2150     case DT_POSFLAG_1:  return "POSFLAG_1";
2151     case DT_SYMINSZ:    return "SYMINSZ";
2152     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
2153
2154     case DT_ADDRRNGLO:  return "ADDRRNGLO";
2155     case DT_CONFIG:     return "CONFIG";
2156     case DT_DEPAUDIT:   return "DEPAUDIT";
2157     case DT_AUDIT:      return "AUDIT";
2158     case DT_PLTPAD:     return "PLTPAD";
2159     case DT_MOVETAB:    return "MOVETAB";
2160     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
2161
2162     case DT_VERSYM:     return "VERSYM";
2163
2164     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2165     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2166     case DT_RELACOUNT:  return "RELACOUNT";
2167     case DT_RELCOUNT:   return "RELCOUNT";
2168     case DT_FLAGS_1:    return "FLAGS_1";
2169     case DT_VERDEF:     return "VERDEF";
2170     case DT_VERDEFNUM:  return "VERDEFNUM";
2171     case DT_VERNEED:    return "VERNEED";
2172     case DT_VERNEEDNUM: return "VERNEEDNUM";
2173
2174     case DT_AUXILIARY:  return "AUXILIARY";
2175     case DT_USED:       return "USED";
2176     case DT_FILTER:     return "FILTER";
2177
2178     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2179     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2180     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2181     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2182     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2183     case DT_GNU_HASH:   return "GNU_HASH";
2184
2185     default:
2186       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2187         {
2188           const char * result;
2189
2190           switch (filedata->file_header.e_machine)
2191             {
2192             case EM_AARCH64:
2193               result = get_aarch64_dynamic_type (type);
2194               break;
2195             case EM_MIPS:
2196             case EM_MIPS_RS3_LE:
2197               result = get_mips_dynamic_type (type);
2198               break;
2199             case EM_SPARCV9:
2200               result = get_sparc64_dynamic_type (type);
2201               break;
2202             case EM_PPC:
2203               result = get_ppc_dynamic_type (type);
2204               break;
2205             case EM_PPC64:
2206               result = get_ppc64_dynamic_type (type);
2207               break;
2208             case EM_IA_64:
2209               result = get_ia64_dynamic_type (type);
2210               break;
2211             case EM_ALPHA:
2212               result = get_alpha_dynamic_type (type);
2213               break;
2214             case EM_SCORE:
2215               result = get_score_dynamic_type (type);
2216               break;
2217             case EM_TI_C6000:
2218               result = get_tic6x_dynamic_type (type);
2219               break;
2220             case EM_ALTERA_NIOS2:
2221               result = get_nios2_dynamic_type (type);
2222               break;
2223             default:
2224               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2225                 result = get_solaris_dynamic_type (type);
2226               else
2227                 result = NULL;
2228               break;
2229             }
2230
2231           if (result != NULL)
2232             return result;
2233
2234           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2235         }
2236       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2237                || (filedata->file_header.e_machine == EM_PARISC
2238                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2239         {
2240           const char * result;
2241
2242           switch (filedata->file_header.e_machine)
2243             {
2244             case EM_PARISC:
2245               result = get_parisc_dynamic_type (type);
2246               break;
2247             case EM_IA_64:
2248               result = get_ia64_dynamic_type (type);
2249               break;
2250             default:
2251               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2252                 result = get_solaris_dynamic_type (type);
2253               else
2254                 result = NULL;
2255               break;
2256             }
2257
2258           if (result != NULL)
2259             return result;
2260
2261           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2262                     type);
2263         }
2264       else
2265         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2266
2267       return buff;
2268     }
2269 }
2270
2271 static char *
2272 get_file_type (unsigned e_type)
2273 {
2274   static char buff[32];
2275
2276   switch (e_type)
2277     {
2278     case ET_NONE: return _("NONE (None)");
2279     case ET_REL:  return _("REL (Relocatable file)");
2280     case ET_EXEC: return _("EXEC (Executable file)");
2281     case ET_DYN:  return _("DYN (Shared object file)");
2282     case ET_CORE: return _("CORE (Core file)");
2283
2284     default:
2285       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2286         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2287       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2288         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2289       else
2290         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2291       return buff;
2292     }
2293 }
2294
2295 static char *
2296 get_machine_name (unsigned e_machine)
2297 {
2298   static char buff[64]; /* XXX */
2299
2300   switch (e_machine)
2301     {
2302       /* Please keep this switch table sorted by increasing EM_ value.  */
2303       /* 0 */
2304     case EM_NONE:               return _("None");
2305     case EM_M32:                return "WE32100";
2306     case EM_SPARC:              return "Sparc";
2307     case EM_386:                return "Intel 80386";
2308     case EM_68K:                return "MC68000";
2309     case EM_88K:                return "MC88000";
2310     case EM_IAMCU:              return "Intel MCU";
2311     case EM_860:                return "Intel 80860";
2312     case EM_MIPS:               return "MIPS R3000";
2313     case EM_S370:               return "IBM System/370";
2314       /* 10 */
2315     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
2316     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
2317     case EM_PARISC:             return "HPPA";
2318     case EM_VPP550:             return "Fujitsu VPP500";
2319     case EM_SPARC32PLUS:        return "Sparc v8+" ;
2320     case EM_960:                return "Intel 80960";
2321     case EM_PPC:                return "PowerPC";
2322       /* 20 */
2323     case EM_PPC64:              return "PowerPC64";
2324     case EM_S390_OLD:
2325     case EM_S390:               return "IBM S/390";
2326     case EM_SPU:                return "SPU";
2327       /* 30 */
2328     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
2329     case EM_FR20:               return "Fujitsu FR20";
2330     case EM_RH32:               return "TRW RH32";
2331     case EM_MCORE:              return "MCORE";
2332       /* 40 */
2333     case EM_ARM:                return "ARM";
2334     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
2335     case EM_SH:                 return "Renesas / SuperH SH";
2336     case EM_SPARCV9:            return "Sparc v9";
2337     case EM_TRICORE:            return "Siemens Tricore";
2338     case EM_ARC:                return "ARC";
2339     case EM_H8_300:             return "Renesas H8/300";
2340     case EM_H8_300H:            return "Renesas H8/300H";
2341     case EM_H8S:                return "Renesas H8S";
2342     case EM_H8_500:             return "Renesas H8/500";
2343       /* 50 */
2344     case EM_IA_64:              return "Intel IA-64";
2345     case EM_MIPS_X:             return "Stanford MIPS-X";
2346     case EM_COLDFIRE:           return "Motorola Coldfire";
2347     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
2348     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
2349     case EM_PCP:                return "Siemens PCP";
2350     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
2351     case EM_NDR1:               return "Denso NDR1 microprocesspr";
2352     case EM_STARCORE:           return "Motorola Star*Core processor";
2353     case EM_ME16:               return "Toyota ME16 processor";
2354       /* 60 */
2355     case EM_ST100:              return "STMicroelectronics ST100 processor";
2356     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
2357     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2358     case EM_PDSP:               return "Sony DSP processor";
2359     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
2360     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
2361     case EM_FX66:               return "Siemens FX66 microcontroller";
2362     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2363     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
2364     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
2365       /* 70 */
2366     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
2367     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
2368     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
2369     case EM_SVX:                return "Silicon Graphics SVx";
2370     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
2371     case EM_VAX:                return "Digital VAX";
2372     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
2373     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
2374     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2375     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2376       /* 80 */
2377     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2378     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2379     case EM_PRISM:              return "Vitesse Prism";
2380     case EM_AVR_OLD:
2381     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
2382     case EM_CYGNUS_FR30:
2383     case EM_FR30:               return "Fujitsu FR30";
2384     case EM_CYGNUS_D10V:
2385     case EM_D10V:               return "d10v";
2386     case EM_CYGNUS_D30V:
2387     case EM_D30V:               return "d30v";
2388     case EM_CYGNUS_V850:
2389     case EM_V850:               return "Renesas V850";
2390     case EM_CYGNUS_M32R:
2391     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
2392     case EM_CYGNUS_MN10300:
2393     case EM_MN10300:            return "mn10300";
2394       /* 90 */
2395     case EM_CYGNUS_MN10200:
2396     case EM_MN10200:            return "mn10200";
2397     case EM_PJ:                 return "picoJava";
2398     case EM_OR1K:               return "OpenRISC 1000";
2399     case EM_ARC_COMPACT:        return "ARCompact";
2400     case EM_XTENSA_OLD:
2401     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2402     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2403     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2404     case EM_NS32K:              return "National Semiconductor 32000 series";
2405     case EM_TPC:                return "Tenor Network TPC processor";
2406     case EM_SNP1K:              return "Trebia SNP 1000 processor";
2407       /* 100 */
2408     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2409     case EM_IP2K_OLD:
2410     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2411     case EM_MAX:                return "MAX Processor";
2412     case EM_CR:                 return "National Semiconductor CompactRISC";
2413     case EM_F2MC16:             return "Fujitsu F2MC16";
2414     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2415     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2416     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2417     case EM_SEP:                return "Sharp embedded microprocessor";
2418     case EM_ARCA:               return "Arca RISC microprocessor";
2419       /* 110 */
2420     case EM_UNICORE:            return "Unicore";
2421     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2422     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2423     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2424     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2425     case EM_XGATE:              return "Motorola XGATE embedded processor";
2426     case EM_C166:
2427     case EM_XC16X:              return "Infineon Technologies xc16x";
2428     case EM_M16C:               return "Renesas M16C series microprocessors";
2429     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2430     case EM_CE:                 return "Freescale Communication Engine RISC core";
2431       /* 120 */
2432     case EM_M32C:               return "Renesas M32c";
2433       /* 130 */
2434     case EM_TSK3000:            return "Altium TSK3000 core";
2435     case EM_RS08:               return "Freescale RS08 embedded processor";
2436     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2437     case EM_SCORE:              return "SUNPLUS S+Core";
2438     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2439     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2440     case EM_LATTICEMICO32:      return "Lattice Mico32";
2441     case EM_SE_C17:             return "Seiko Epson C17 family";
2442       /* 140 */
2443     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2444     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2445     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2446     case EM_TI_PRU:             return "TI PRU I/O processor";
2447       /* 160 */
2448     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2449     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2450     case EM_R32C:               return "Renesas R32C series microprocessors";
2451     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2452     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2453     case EM_8051:               return "Intel 8051 and variants";
2454     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2455     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2456     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2457     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2458       /* 170 */
2459     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2460     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2461     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2462     case EM_RX:                 return "Renesas RX";
2463     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2464     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2465     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2466     case EM_CR16:
2467     case EM_MICROBLAZE:
2468     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2469     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2470     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2471       /* 180 */
2472     case EM_L1OM:               return "Intel L1OM";
2473     case EM_K1OM:               return "Intel K1OM";
2474     case EM_INTEL182:           return "Intel (reserved)";
2475     case EM_AARCH64:            return "AArch64";
2476     case EM_ARM184:             return "ARM (reserved)";
2477     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor";
2478     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2479     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2480     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2481       /* 190 */
2482     case EM_CUDA:               return "NVIDIA CUDA architecture";
2483     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2484     case EM_CLOUDSHIELD:        return "CloudShield architecture family";
2485     case EM_COREA_1ST:          return "KIPO-KAIST Core-A 1st generation processor family";
2486     case EM_COREA_2ND:          return "KIPO-KAIST Core-A 2nd generation processor family";
2487     case EM_ARC_COMPACT2:       return "ARCv2";
2488     case EM_OPEN8:              return "Open8 8-bit RISC soft processor core";
2489     case EM_RL78:               return "Renesas RL78";
2490     case EM_VIDEOCORE5:         return "Broadcom VideoCore V processor";
2491     case EM_78K0R:              return "Renesas 78K0R";
2492       /* 200 */
2493     case EM_56800EX:            return "Freescale 56800EX Digital Signal Controller (DSC)";
2494     case EM_BA1:                return "Beyond BA1 CPU architecture";
2495     case EM_BA2:                return "Beyond BA2 CPU architecture";
2496     case EM_XCORE:              return "XMOS xCORE processor family";
2497     case EM_MCHP_PIC:           return "Microchip 8-bit PIC(r) family";
2498       /* 210 */
2499     case EM_KM32:               return "KM211 KM32 32-bit processor";
2500     case EM_KMX32:              return "KM211 KMX32 32-bit processor";
2501     case EM_KMX16:              return "KM211 KMX16 16-bit processor";
2502     case EM_KMX8:               return "KM211 KMX8 8-bit processor";
2503     case EM_KVARC:              return "KM211 KVARC processor";
2504     case EM_CDP:                return "Paneve CDP architecture family";
2505     case EM_COGE:               return "Cognitive Smart Memory Processor";
2506     case EM_COOL:               return "Bluechip Systems CoolEngine";
2507     case EM_NORC:               return "Nanoradio Optimized RISC";
2508     case EM_CSR_KALIMBA:        return "CSR Kalimba architecture family";
2509       /* 220 */
2510     case EM_Z80:                return "Zilog Z80";
2511     case EM_VISIUM:             return "CDS VISIUMcore processor";
2512     case EM_FT32:               return "FTDI Chip FT32";
2513     case EM_MOXIE:              return "Moxie";
2514     case EM_AMDGPU:             return "AMD GPU";
2515     case EM_RISCV:              return "RISC-V";
2516     case EM_LANAI:              return "Lanai 32-bit processor";
2517     case EM_BPF:                return "Linux BPF";
2518     case EM_NFP:                return "Netronome Flow Processor";
2519
2520       /* Large numbers...  */
2521     case EM_MT:                 return "Morpho Techologies MT processor";
2522     case EM_ALPHA:              return "Alpha";
2523     case EM_WEBASSEMBLY:        return "Web Assembly";
2524     case EM_DLX:                return "OpenDLX";
2525     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2526     case EM_IQ2000:             return "Vitesse IQ2000";
2527     case EM_M32C_OLD:
2528     case EM_NIOS32:             return "Altera Nios";
2529     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2530     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2531     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
2532     case EM_S12Z:               return "Freescale S12Z";
2533     case EM_CSKY:               return "C-SKY";
2534
2535     default:
2536       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2537       return buff;
2538     }
2539 }
2540
2541 static void
2542 decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2543 {
2544   /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2.  Some
2545      other compilers don't a specific architecture type in the e_flags, and
2546      instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2547      architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2548      architectures.
2549
2550      Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2551      but also sets a specific architecture type in the e_flags field.
2552
2553      However, when decoding the flags we don't worry if we see an
2554      unexpected pairing, for example EM_ARC_COMPACT machine type, with
2555      ARCEM architecture type.  */
2556
2557   switch (e_flags & EF_ARC_MACH_MSK)
2558     {
2559       /* We only expect these to occur for EM_ARC_COMPACT2.  */
2560     case EF_ARC_CPU_ARCV2EM:
2561       strcat (buf, ", ARC EM");
2562       break;
2563     case EF_ARC_CPU_ARCV2HS:
2564       strcat (buf, ", ARC HS");
2565       break;
2566
2567       /* We only expect these to occur for EM_ARC_COMPACT.  */
2568     case E_ARC_MACH_ARC600:
2569       strcat (buf, ", ARC600");
2570       break;
2571     case E_ARC_MACH_ARC601:
2572       strcat (buf, ", ARC601");
2573       break;
2574     case E_ARC_MACH_ARC700:
2575       strcat (buf, ", ARC700");
2576       break;
2577
2578       /* The only times we should end up here are (a) A corrupt ELF, (b) A
2579          new ELF with new architecture being read by an old version of
2580          readelf, or (c) An ELF built with non-GNU compiler that does not
2581          set the architecture in the e_flags.  */
2582     default:
2583       if (e_machine == EM_ARC_COMPACT)
2584         strcat (buf, ", Unknown ARCompact");
2585       else
2586         strcat (buf, ", Unknown ARC");
2587       break;
2588     }
2589
2590   switch (e_flags & EF_ARC_OSABI_MSK)
2591     {
2592     case E_ARC_OSABI_ORIG:
2593       strcat (buf, ", (ABI:legacy)");
2594       break;
2595     case E_ARC_OSABI_V2:
2596       strcat (buf, ", (ABI:v2)");
2597       break;
2598       /* Only upstream 3.9+ kernels will support ARCv2 ISA.  */
2599     case E_ARC_OSABI_V3:
2600       strcat (buf, ", v3 no-legacy-syscalls ABI");
2601       break;
2602     case E_ARC_OSABI_V4:
2603       strcat (buf, ", v4 ABI");
2604       break;
2605     default:
2606       strcat (buf, ", unrecognised ARC OSABI flag");
2607       break;
2608     }
2609 }
2610
2611 static void
2612 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2613 {
2614   unsigned eabi;
2615   bfd_boolean unknown = FALSE;
2616
2617   eabi = EF_ARM_EABI_VERSION (e_flags);
2618   e_flags &= ~ EF_ARM_EABIMASK;
2619
2620   /* Handle "generic" ARM flags.  */
2621   if (e_flags & EF_ARM_RELEXEC)
2622     {
2623       strcat (buf, ", relocatable executable");
2624       e_flags &= ~ EF_ARM_RELEXEC;
2625     }
2626
2627   if (e_flags & EF_ARM_PIC)
2628     {
2629       strcat (buf, ", position independent");
2630       e_flags &= ~ EF_ARM_PIC;
2631     }
2632
2633   /* Now handle EABI specific flags.  */
2634   switch (eabi)
2635     {
2636     default:
2637       strcat (buf, ", <unrecognized EABI>");
2638       if (e_flags)
2639         unknown = TRUE;
2640       break;
2641
2642     case EF_ARM_EABI_VER1:
2643       strcat (buf, ", Version1 EABI");
2644       while (e_flags)
2645         {
2646           unsigned flag;
2647
2648           /* Process flags one bit at a time.  */
2649           flag = e_flags & - e_flags;
2650           e_flags &= ~ flag;
2651
2652           switch (flag)
2653             {
2654             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2655               strcat (buf, ", sorted symbol tables");
2656               break;
2657
2658             default:
2659               unknown = TRUE;
2660               break;
2661             }
2662         }
2663       break;
2664
2665     case EF_ARM_EABI_VER2:
2666       strcat (buf, ", Version2 EABI");
2667       while (e_flags)
2668         {
2669           unsigned flag;
2670
2671           /* Process flags one bit at a time.  */
2672           flag = e_flags & - e_flags;
2673           e_flags &= ~ flag;
2674
2675           switch (flag)
2676             {
2677             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2678               strcat (buf, ", sorted symbol tables");
2679               break;
2680
2681             case EF_ARM_DYNSYMSUSESEGIDX:
2682               strcat (buf, ", dynamic symbols use segment index");
2683               break;
2684
2685             case EF_ARM_MAPSYMSFIRST:
2686               strcat (buf, ", mapping symbols precede others");
2687               break;
2688
2689             default:
2690               unknown = TRUE;
2691               break;
2692             }
2693         }
2694       break;
2695
2696     case EF_ARM_EABI_VER3:
2697       strcat (buf, ", Version3 EABI");
2698       break;
2699
2700     case EF_ARM_EABI_VER4:
2701       strcat (buf, ", Version4 EABI");
2702       while (e_flags)
2703         {
2704           unsigned flag;
2705
2706           /* Process flags one bit at a time.  */
2707           flag = e_flags & - e_flags;
2708           e_flags &= ~ flag;
2709
2710           switch (flag)
2711             {
2712             case EF_ARM_BE8:
2713               strcat (buf, ", BE8");
2714               break;
2715
2716             case EF_ARM_LE8:
2717               strcat (buf, ", LE8");
2718               break;
2719
2720             default:
2721               unknown = TRUE;
2722               break;
2723             }
2724         }
2725       break;
2726
2727     case EF_ARM_EABI_VER5:
2728       strcat (buf, ", Version5 EABI");
2729       while (e_flags)
2730         {
2731           unsigned flag;
2732
2733           /* Process flags one bit at a time.  */
2734           flag = e_flags & - e_flags;
2735           e_flags &= ~ flag;
2736
2737           switch (flag)
2738             {
2739             case EF_ARM_BE8:
2740               strcat (buf, ", BE8");
2741               break;
2742
2743             case EF_ARM_LE8:
2744               strcat (buf, ", LE8");
2745               break;
2746
2747             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2748               strcat (buf, ", soft-float ABI");
2749               break;
2750
2751             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2752               strcat (buf, ", hard-float ABI");
2753               break;
2754
2755             default:
2756               unknown = TRUE;
2757               break;
2758             }
2759         }
2760       break;
2761
2762     case EF_ARM_EABI_UNKNOWN:
2763       strcat (buf, ", GNU EABI");
2764       while (e_flags)
2765         {
2766           unsigned flag;
2767
2768           /* Process flags one bit at a time.  */
2769           flag = e_flags & - e_flags;
2770           e_flags &= ~ flag;
2771
2772           switch (flag)
2773             {
2774             case EF_ARM_INTERWORK:
2775               strcat (buf, ", interworking enabled");
2776               break;
2777
2778             case EF_ARM_APCS_26:
2779               strcat (buf, ", uses APCS/26");
2780               break;
2781
2782             case EF_ARM_APCS_FLOAT:
2783               strcat (buf, ", uses APCS/float");
2784               break;
2785
2786             case EF_ARM_PIC:
2787               strcat (buf, ", position independent");
2788               break;
2789
2790             case EF_ARM_ALIGN8:
2791               strcat (buf, ", 8 bit structure alignment");
2792               break;
2793
2794             case EF_ARM_NEW_ABI:
2795               strcat (buf, ", uses new ABI");
2796               break;
2797
2798             case EF_ARM_OLD_ABI:
2799               strcat (buf, ", uses old ABI");
2800               break;
2801
2802             case EF_ARM_SOFT_FLOAT:
2803               strcat (buf, ", software FP");
2804               break;
2805
2806             case EF_ARM_VFP_FLOAT:
2807               strcat (buf, ", VFP");
2808               break;
2809
2810             case EF_ARM_MAVERICK_FLOAT:
2811               strcat (buf, ", Maverick FP");
2812               break;
2813
2814             default:
2815               unknown = TRUE;
2816               break;
2817             }
2818         }
2819     }
2820
2821   if (unknown)
2822     strcat (buf,_(", <unknown>"));
2823 }
2824
2825 static void
2826 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2827 {
2828   --size; /* Leave space for null terminator.  */
2829
2830   switch (e_flags & EF_AVR_MACH)
2831     {
2832     case E_AVR_MACH_AVR1:
2833       strncat (buf, ", avr:1", size);
2834       break;
2835     case E_AVR_MACH_AVR2:
2836       strncat (buf, ", avr:2", size);
2837       break;
2838     case E_AVR_MACH_AVR25:
2839       strncat (buf, ", avr:25", size);
2840       break;
2841     case E_AVR_MACH_AVR3:
2842       strncat (buf, ", avr:3", size);
2843       break;
2844     case E_AVR_MACH_AVR31:
2845       strncat (buf, ", avr:31", size);
2846       break;
2847     case E_AVR_MACH_AVR35:
2848       strncat (buf, ", avr:35", size);
2849       break;
2850     case E_AVR_MACH_AVR4:
2851       strncat (buf, ", avr:4", size);
2852       break;
2853     case E_AVR_MACH_AVR5:
2854       strncat (buf, ", avr:5", size);
2855       break;
2856     case E_AVR_MACH_AVR51:
2857       strncat (buf, ", avr:51", size);
2858       break;
2859     case E_AVR_MACH_AVR6:
2860       strncat (buf, ", avr:6", size);
2861       break;
2862     case E_AVR_MACH_AVRTINY:
2863       strncat (buf, ", avr:100", size);
2864       break;
2865     case E_AVR_MACH_XMEGA1:
2866       strncat (buf, ", avr:101", size);
2867       break;
2868     case E_AVR_MACH_XMEGA2:
2869       strncat (buf, ", avr:102", size);
2870       break;
2871     case E_AVR_MACH_XMEGA3:
2872       strncat (buf, ", avr:103", size);
2873       break;
2874     case E_AVR_MACH_XMEGA4:
2875       strncat (buf, ", avr:104", size);
2876       break;
2877     case E_AVR_MACH_XMEGA5:
2878       strncat (buf, ", avr:105", size);
2879       break;
2880     case E_AVR_MACH_XMEGA6:
2881       strncat (buf, ", avr:106", size);
2882       break;
2883     case E_AVR_MACH_XMEGA7:
2884       strncat (buf, ", avr:107", size);
2885       break;
2886     default:
2887       strncat (buf, ", avr:<unknown>", size);
2888       break;
2889     }
2890
2891   size -= strlen (buf);
2892   if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2893     strncat (buf, ", link-relax", size);
2894 }
2895
2896 static void
2897 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2898 {
2899   unsigned abi;
2900   unsigned arch;
2901   unsigned config;
2902   unsigned version;
2903   bfd_boolean has_fpu = FALSE;
2904   unsigned int r = 0;
2905
2906   static const char *ABI_STRINGS[] =
2907   {
2908     "ABI v0", /* use r5 as return register; only used in N1213HC */
2909     "ABI v1", /* use r0 as return register */
2910     "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2911     "ABI v2fp", /* for FPU */
2912     "AABI",
2913     "ABI2 FP+"
2914   };
2915   static const char *VER_STRINGS[] =
2916   {
2917     "Andes ELF V1.3 or older",
2918     "Andes ELF V1.3.1",
2919     "Andes ELF V1.4"
2920   };
2921   static const char *ARCH_STRINGS[] =
2922   {
2923     "",
2924     "Andes Star v1.0",
2925     "Andes Star v2.0",
2926     "Andes Star v3.0",
2927     "Andes Star v3.0m"
2928   };
2929
2930   abi = EF_NDS_ABI & e_flags;
2931   arch = EF_NDS_ARCH & e_flags;
2932   config = EF_NDS_INST & e_flags;
2933   version = EF_NDS32_ELF_VERSION & e_flags;
2934
2935   memset (buf, 0, size);
2936
2937   switch (abi)
2938     {
2939     case E_NDS_ABI_V0:
2940     case E_NDS_ABI_V1:
2941     case E_NDS_ABI_V2:
2942     case E_NDS_ABI_V2FP:
2943     case E_NDS_ABI_AABI:
2944     case E_NDS_ABI_V2FP_PLUS:
2945       /* In case there are holes in the array.  */
2946       r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2947       break;
2948
2949     default:
2950       r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2951       break;
2952     }
2953
2954   switch (version)
2955     {
2956     case E_NDS32_ELF_VER_1_2:
2957     case E_NDS32_ELF_VER_1_3:
2958     case E_NDS32_ELF_VER_1_4:
2959       r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2960       break;
2961
2962     default:
2963       r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2964       break;
2965     }
2966
2967   if (E_NDS_ABI_V0 == abi)
2968     {
2969       /* OLD ABI; only used in N1213HC, has performance extension 1.  */
2970       r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2971       if (arch == E_NDS_ARCH_STAR_V1_0)
2972         r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2973       return;
2974     }
2975
2976   switch (arch)
2977     {
2978     case E_NDS_ARCH_STAR_V1_0:
2979     case E_NDS_ARCH_STAR_V2_0:
2980     case E_NDS_ARCH_STAR_V3_0:
2981     case E_NDS_ARCH_STAR_V3_M:
2982       r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2983       break;
2984
2985     default:
2986       r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2987       /* ARCH version determines how the e_flags are interpreted.
2988          If it is unknown, we cannot proceed.  */
2989       return;
2990     }
2991
2992   /* Newer ABI; Now handle architecture specific flags.  */
2993   if (arch == E_NDS_ARCH_STAR_V1_0)
2994     {
2995       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2996         r += snprintf (buf + r, size -r, ", MFUSR_PC");
2997
2998       if (!(config & E_NDS32_HAS_NO_MAC_INST))
2999         r += snprintf (buf + r, size -r, ", MAC");
3000
3001       if (config & E_NDS32_HAS_DIV_INST)
3002         r += snprintf (buf + r, size -r, ", DIV");
3003
3004       if (config & E_NDS32_HAS_16BIT_INST)
3005         r += snprintf (buf + r, size -r, ", 16b");
3006     }
3007   else
3008     {
3009       if (config & E_NDS32_HAS_MFUSR_PC_INST)
3010         {
3011           if (version <= E_NDS32_ELF_VER_1_3)
3012             r += snprintf (buf + r, size -r, ", [B8]");
3013           else
3014             r += snprintf (buf + r, size -r, ", EX9");
3015         }
3016
3017       if (config & E_NDS32_HAS_MAC_DX_INST)
3018         r += snprintf (buf + r, size -r, ", MAC_DX");
3019
3020       if (config & E_NDS32_HAS_DIV_DX_INST)
3021         r += snprintf (buf + r, size -r, ", DIV_DX");
3022
3023       if (config & E_NDS32_HAS_16BIT_INST)
3024         {
3025           if (version <= E_NDS32_ELF_VER_1_3)
3026             r += snprintf (buf + r, size -r, ", 16b");
3027           else
3028             r += snprintf (buf + r, size -r, ", IFC");
3029         }
3030     }
3031
3032   if (config & E_NDS32_HAS_EXT_INST)
3033     r += snprintf (buf + r, size -r, ", PERF1");
3034
3035   if (config & E_NDS32_HAS_EXT2_INST)
3036     r += snprintf (buf + r, size -r, ", PERF2");
3037
3038   if (config & E_NDS32_HAS_FPU_INST)
3039     {
3040       has_fpu = TRUE;
3041       r += snprintf (buf + r, size -r, ", FPU_SP");
3042     }
3043
3044   if (config & E_NDS32_HAS_FPU_DP_INST)
3045     {
3046       has_fpu = TRUE;
3047       r += snprintf (buf + r, size -r, ", FPU_DP");
3048     }
3049
3050   if (config & E_NDS32_HAS_FPU_MAC_INST)
3051     {
3052       has_fpu = TRUE;
3053       r += snprintf (buf + r, size -r, ", FPU_MAC");
3054     }
3055
3056   if (has_fpu)
3057     {
3058       switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
3059         {
3060         case E_NDS32_FPU_REG_8SP_4DP:
3061           r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
3062           break;
3063         case E_NDS32_FPU_REG_16SP_8DP:
3064           r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
3065           break;
3066         case E_NDS32_FPU_REG_32SP_16DP:
3067           r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
3068           break;
3069         case E_NDS32_FPU_REG_32SP_32DP:
3070           r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
3071           break;
3072         }
3073     }
3074
3075   if (config & E_NDS32_HAS_AUDIO_INST)
3076     r += snprintf (buf + r, size -r, ", AUDIO");
3077
3078   if (config & E_NDS32_HAS_STRING_INST)
3079     r += snprintf (buf + r, size -r, ", STR");
3080
3081   if (config & E_NDS32_HAS_REDUCED_REGS)
3082     r += snprintf (buf + r, size -r, ", 16REG");
3083
3084   if (config & E_NDS32_HAS_VIDEO_INST)
3085     {
3086       if (version <= E_NDS32_ELF_VER_1_3)
3087         r += snprintf (buf + r, size -r, ", VIDEO");
3088       else
3089         r += snprintf (buf + r, size -r, ", SATURATION");
3090     }
3091
3092   if (config & E_NDS32_HAS_ENCRIPT_INST)
3093     r += snprintf (buf + r, size -r, ", ENCRP");
3094
3095   if (config & E_NDS32_HAS_L2C_INST)
3096     r += snprintf (buf + r, size -r, ", L2C");
3097 }
3098
3099 static char *
3100 get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine)
3101 {
3102   static char buf[1024];
3103
3104   buf[0] = '\0';
3105
3106   if (e_flags)
3107     {
3108       switch (e_machine)
3109         {
3110         default:
3111           break;
3112
3113         case EM_ARC_COMPACT2:
3114         case EM_ARC_COMPACT:
3115           decode_ARC_machine_flags (e_flags, e_machine, buf);
3116           break;
3117
3118         case EM_ARM:
3119           decode_ARM_machine_flags (e_flags, buf);
3120           break;
3121
3122         case EM_AVR:
3123           decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3124           break;
3125
3126         case EM_BLACKFIN:
3127           if (e_flags & EF_BFIN_PIC)
3128             strcat (buf, ", PIC");
3129
3130           if (e_flags & EF_BFIN_FDPIC)
3131             strcat (buf, ", FDPIC");
3132
3133           if (e_flags & EF_BFIN_CODE_IN_L1)
3134             strcat (buf, ", code in L1");
3135
3136           if (e_flags & EF_BFIN_DATA_IN_L1)
3137             strcat (buf, ", data in L1");
3138
3139           break;
3140
3141         case EM_CYGNUS_FRV:
3142           switch (e_flags & EF_FRV_CPU_MASK)
3143             {
3144             case EF_FRV_CPU_GENERIC:
3145               break;
3146
3147             default:
3148               strcat (buf, ", fr???");
3149               break;
3150
3151             case EF_FRV_CPU_FR300:
3152               strcat (buf, ", fr300");
3153               break;
3154
3155             case EF_FRV_CPU_FR400:
3156               strcat (buf, ", fr400");
3157               break;
3158             case EF_FRV_CPU_FR405:
3159               strcat (buf, ", fr405");
3160               break;
3161
3162             case EF_FRV_CPU_FR450:
3163               strcat (buf, ", fr450");
3164               break;
3165
3166             case EF_FRV_CPU_FR500:
3167               strcat (buf, ", fr500");
3168               break;
3169             case EF_FRV_CPU_FR550:
3170               strcat (buf, ", fr550");
3171               break;
3172
3173             case EF_FRV_CPU_SIMPLE:
3174               strcat (buf, ", simple");
3175               break;
3176             case EF_FRV_CPU_TOMCAT:
3177               strcat (buf, ", tomcat");
3178               break;
3179             }
3180           break;
3181
3182         case EM_68K:
3183           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3184             strcat (buf, ", m68000");
3185           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3186             strcat (buf, ", cpu32");
3187           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3188             strcat (buf, ", fido_a");
3189           else
3190             {
3191               char const * isa = _("unknown");
3192               char const * mac = _("unknown mac");
3193               char const * additional = NULL;
3194
3195               switch (e_flags & EF_M68K_CF_ISA_MASK)
3196                 {
3197                 case EF_M68K_CF_ISA_A_NODIV:
3198                   isa = "A";
3199                   additional = ", nodiv";
3200                   break;
3201                 case EF_M68K_CF_ISA_A:
3202                   isa = "A";
3203                   break;
3204                 case EF_M68K_CF_ISA_A_PLUS:
3205                   isa = "A+";
3206                   break;
3207                 case EF_M68K_CF_ISA_B_NOUSP:
3208                   isa = "B";
3209                   additional = ", nousp";
3210                   break;
3211                 case EF_M68K_CF_ISA_B:
3212                   isa = "B";
3213                   break;
3214                 case EF_M68K_CF_ISA_C:
3215                   isa = "C";
3216                   break;
3217                 case EF_M68K_CF_ISA_C_NODIV:
3218                   isa = "C";
3219                   additional = ", nodiv";
3220                   break;
3221                 }
3222               strcat (buf, ", cf, isa ");
3223               strcat (buf, isa);
3224               if (additional)
3225                 strcat (buf, additional);
3226               if (e_flags & EF_M68K_CF_FLOAT)
3227                 strcat (buf, ", float");
3228               switch (e_flags & EF_M68K_CF_MAC_MASK)
3229                 {
3230                 case 0:
3231                   mac = NULL;
3232                   break;
3233                 case EF_M68K_CF_MAC:
3234                   mac = "mac";
3235                   break;
3236                 case EF_M68K_CF_EMAC:
3237                   mac = "emac";
3238                   break;
3239                 case EF_M68K_CF_EMAC_B:
3240                   mac = "emac_b";
3241                   break;
3242                 }
3243               if (mac)
3244                 {
3245                   strcat (buf, ", ");
3246                   strcat (buf, mac);
3247                 }
3248             }
3249           break;
3250
3251         case EM_CYGNUS_MEP:
3252           switch (e_flags & EF_MEP_CPU_MASK)
3253             {
3254             case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3255             case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3256             case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3257             case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3258             case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3259             case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3260             default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3261             }
3262
3263           switch (e_flags & EF_MEP_COP_MASK)
3264             {
3265             case EF_MEP_COP_NONE: break;
3266             case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3267             case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3268             case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3269             case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3270             default: strcat (buf, _("<unknown MeP copro type>")); break;
3271             }
3272
3273           if (e_flags & EF_MEP_LIBRARY)
3274             strcat (buf, ", Built for Library");
3275
3276           if (e_flags & EF_MEP_INDEX_MASK)
3277             sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3278                      e_flags & EF_MEP_INDEX_MASK);
3279
3280           if (e_flags & ~ EF_MEP_ALL_FLAGS)
3281             sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3282                      e_flags & ~ EF_MEP_ALL_FLAGS);
3283           break;
3284
3285         case EM_PPC:
3286           if (e_flags & EF_PPC_EMB)
3287             strcat (buf, ", emb");
3288
3289           if (e_flags & EF_PPC_RELOCATABLE)
3290             strcat (buf, _(", relocatable"));
3291
3292           if (e_flags & EF_PPC_RELOCATABLE_LIB)
3293             strcat (buf, _(", relocatable-lib"));
3294           break;
3295
3296         case EM_PPC64:
3297           if (e_flags & EF_PPC64_ABI)
3298             {
3299               char abi[] = ", abiv0";
3300
3301               abi[6] += e_flags & EF_PPC64_ABI;
3302               strcat (buf, abi);
3303             }
3304           break;
3305
3306         case EM_V800:
3307           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3308             strcat (buf, ", RH850 ABI");
3309
3310           if (e_flags & EF_V800_850E3)
3311             strcat (buf, ", V3 architecture");
3312
3313           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3314             strcat (buf, ", FPU not used");
3315
3316           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3317             strcat (buf, ", regmode: COMMON");
3318
3319           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3320             strcat (buf, ", r4 not used");
3321
3322           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3323             strcat (buf, ", r30 not used");
3324
3325           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3326             strcat (buf, ", r5 not used");
3327
3328           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3329             strcat (buf, ", r2 not used");
3330
3331           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3332             {
3333               switch (e_flags & - e_flags)
3334                 {
3335                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3336                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3337                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3338                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3339                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3340                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3341                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3342                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3343                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3344                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3345                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3346                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3347                 default: break;
3348                 }
3349             }
3350           break;
3351
3352         case EM_V850:
3353         case EM_CYGNUS_V850:
3354           switch (e_flags & EF_V850_ARCH)
3355             {
3356             case E_V850E3V5_ARCH:
3357               strcat (buf, ", v850e3v5");
3358               break;
3359             case E_V850E2V3_ARCH:
3360               strcat (buf, ", v850e2v3");
3361               break;
3362             case E_V850E2_ARCH:
3363               strcat (buf, ", v850e2");
3364               break;
3365             case E_V850E1_ARCH:
3366               strcat (buf, ", v850e1");
3367               break;
3368             case E_V850E_ARCH:
3369               strcat (buf, ", v850e");
3370               break;
3371             case E_V850_ARCH:
3372               strcat (buf, ", v850");
3373               break;
3374             default:
3375               strcat (buf, _(", unknown v850 architecture variant"));
3376               break;
3377             }
3378           break;
3379
3380         case EM_M32R:
3381         case EM_CYGNUS_M32R:
3382           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3383             strcat (buf, ", m32r");
3384           break;
3385
3386         case EM_MIPS:
3387         case EM_MIPS_RS3_LE:
3388           if (e_flags & EF_MIPS_NOREORDER)
3389             strcat (buf, ", noreorder");
3390
3391           if (e_flags & EF_MIPS_PIC)
3392             strcat (buf, ", pic");
3393
3394           if (e_flags & EF_MIPS_CPIC)
3395             strcat (buf, ", cpic");
3396
3397           if (e_flags & EF_MIPS_UCODE)
3398             strcat (buf, ", ugen_reserved");
3399
3400           if (e_flags & EF_MIPS_ABI2)
3401             strcat (buf, ", abi2");
3402
3403           if (e_flags & EF_MIPS_OPTIONS_FIRST)
3404             strcat (buf, ", odk first");
3405
3406           if (e_flags & EF_MIPS_32BITMODE)
3407             strcat (buf, ", 32bitmode");
3408
3409           if (e_flags & EF_MIPS_NAN2008)
3410             strcat (buf, ", nan2008");
3411
3412           if (e_flags & EF_MIPS_FP64)
3413             strcat (buf, ", fp64");
3414
3415           switch ((e_flags & EF_MIPS_MACH))
3416             {
3417             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3418             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3419             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3420             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3421             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3422             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3423             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3424             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3425             case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break;
3426             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
3427             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3428             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3429             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3430             case E_MIPS_MACH_GS464: strcat (buf, ", gs464"); break;
3431             case E_MIPS_MACH_GS464E: strcat (buf, ", gs464e"); break;
3432             case E_MIPS_MACH_GS264E: strcat (buf, ", gs264e"); break;
3433             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3434             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3435             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3436             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
3437             case E_MIPS_MACH_IAMR2:  strcat (buf, ", interaptiv-mr2"); break;
3438             case 0:
3439             /* We simply ignore the field in this case to avoid confusion:
3440                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3441                extension.  */
3442               break;
3443             default: strcat (buf, _(", unknown CPU")); break;
3444             }
3445
3446           switch ((e_flags & EF_MIPS_ABI))
3447             {
3448             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3449             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3450             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3451             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3452             case 0:
3453             /* We simply ignore the field in this case to avoid confusion:
3454                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3455                This means it is likely to be an o32 file, but not for
3456                sure.  */
3457               break;
3458             default: strcat (buf, _(", unknown ABI")); break;
3459             }
3460
3461           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3462             strcat (buf, ", mdmx");
3463
3464           if (e_flags & EF_MIPS_ARCH_ASE_M16)
3465             strcat (buf, ", mips16");
3466
3467           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3468             strcat (buf, ", micromips");
3469
3470           switch ((e_flags & EF_MIPS_ARCH))
3471             {
3472             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3473             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3474             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3475             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3476             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3477             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3478             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3479             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3480             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3481             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3482             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3483             default: strcat (buf, _(", unknown ISA")); break;
3484             }
3485           break;
3486
3487         case EM_NDS32:
3488           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3489           break;
3490
3491         case EM_NFP:
3492           switch (EF_NFP_MACH (e_flags))
3493             {
3494             case E_NFP_MACH_3200:
3495               strcat (buf, ", NFP-32xx");
3496               break;
3497             case E_NFP_MACH_6000:
3498               strcat (buf, ", NFP-6xxx");
3499               break;
3500             }
3501           break;
3502
3503         case EM_RISCV:
3504           if (e_flags & EF_RISCV_RVC)
3505             strcat (buf, ", RVC");
3506
3507           if (e_flags & EF_RISCV_RVE)
3508             strcat (buf, ", RVE");
3509
3510           switch (e_flags & EF_RISCV_FLOAT_ABI)
3511             {
3512             case EF_RISCV_FLOAT_ABI_SOFT:
3513               strcat (buf, ", soft-float ABI");
3514               break;
3515
3516             case EF_RISCV_FLOAT_ABI_SINGLE:
3517               strcat (buf, ", single-float ABI");
3518               break;
3519
3520             case EF_RISCV_FLOAT_ABI_DOUBLE:
3521               strcat (buf, ", double-float ABI");
3522               break;
3523
3524             case EF_RISCV_FLOAT_ABI_QUAD:
3525               strcat (buf, ", quad-float ABI");
3526               break;
3527             }
3528           break;
3529
3530         case EM_SH:
3531           switch ((e_flags & EF_SH_MACH_MASK))
3532             {
3533             case EF_SH1: strcat (buf, ", sh1"); break;
3534             case EF_SH2: strcat (buf, ", sh2"); break;
3535             case EF_SH3: strcat (buf, ", sh3"); break;
3536             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3537             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3538             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3539             case EF_SH3E: strcat (buf, ", sh3e"); break;
3540             case EF_SH4: strcat (buf, ", sh4"); break;
3541             case EF_SH5: strcat (buf, ", sh5"); break;
3542             case EF_SH2E: strcat (buf, ", sh2e"); break;
3543             case EF_SH4A: strcat (buf, ", sh4a"); break;
3544             case EF_SH2A: strcat (buf, ", sh2a"); break;
3545             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3546             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3547             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3548             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3549             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3550             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3551             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3552             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3553             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3554             default: strcat (buf, _(", unknown ISA")); break;
3555             }
3556
3557           if (e_flags & EF_SH_PIC)
3558             strcat (buf, ", pic");
3559
3560           if (e_flags & EF_SH_FDPIC)
3561             strcat (buf, ", fdpic");
3562           break;
3563
3564         case EM_OR1K:
3565           if (e_flags & EF_OR1K_NODELAY)
3566             strcat (buf, ", no delay");
3567           break;
3568
3569         case EM_SPARCV9:
3570           if (e_flags & EF_SPARC_32PLUS)
3571             strcat (buf, ", v8+");
3572
3573           if (e_flags & EF_SPARC_SUN_US1)
3574             strcat (buf, ", ultrasparcI");
3575
3576           if (e_flags & EF_SPARC_SUN_US3)
3577             strcat (buf, ", ultrasparcIII");
3578
3579           if (e_flags & EF_SPARC_HAL_R1)
3580             strcat (buf, ", halr1");
3581
3582           if (e_flags & EF_SPARC_LEDATA)
3583             strcat (buf, ", ledata");
3584
3585           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3586             strcat (buf, ", tso");
3587
3588           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3589             strcat (buf, ", pso");
3590
3591           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3592             strcat (buf, ", rmo");
3593           break;
3594
3595         case EM_PARISC:
3596           switch (e_flags & EF_PARISC_ARCH)
3597             {
3598             case EFA_PARISC_1_0:
3599               strcpy (buf, ", PA-RISC 1.0");
3600               break;
3601             case EFA_PARISC_1_1:
3602               strcpy (buf, ", PA-RISC 1.1");
3603               break;
3604             case EFA_PARISC_2_0:
3605               strcpy (buf, ", PA-RISC 2.0");
3606               break;
3607             default:
3608               break;
3609             }
3610           if (e_flags & EF_PARISC_TRAPNIL)
3611             strcat (buf, ", trapnil");
3612           if (e_flags & EF_PARISC_EXT)
3613             strcat (buf, ", ext");
3614           if (e_flags & EF_PARISC_LSB)
3615             strcat (buf, ", lsb");
3616           if (e_flags & EF_PARISC_WIDE)
3617             strcat (buf, ", wide");
3618           if (e_flags & EF_PARISC_NO_KABP)
3619             strcat (buf, ", no kabp");
3620           if (e_flags & EF_PARISC_LAZYSWAP)
3621             strcat (buf, ", lazyswap");
3622           break;
3623
3624         case EM_PJ:
3625         case EM_PJ_OLD:
3626           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3627             strcat (buf, ", new calling convention");
3628
3629           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3630             strcat (buf, ", gnu calling convention");
3631           break;
3632
3633         case EM_IA_64:
3634           if ((e_flags & EF_IA_64_ABI64))
3635             strcat (buf, ", 64-bit");
3636           else
3637             strcat (buf, ", 32-bit");
3638           if ((e_flags & EF_IA_64_REDUCEDFP))
3639             strcat (buf, ", reduced fp model");
3640           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3641             strcat (buf, ", no function descriptors, constant gp");
3642           else if ((e_flags & EF_IA_64_CONS_GP))
3643             strcat (buf, ", constant gp");
3644           if ((e_flags & EF_IA_64_ABSOLUTE))
3645             strcat (buf, ", absolute");
3646           if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3647             {
3648               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3649                 strcat (buf, ", vms_linkages");
3650               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3651                 {
3652                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3653                   break;
3654                 case EF_IA_64_VMS_COMCOD_WARNING:
3655                   strcat (buf, ", warning");
3656                   break;
3657                 case EF_IA_64_VMS_COMCOD_ERROR:
3658                   strcat (buf, ", error");
3659                   break;
3660                 case EF_IA_64_VMS_COMCOD_ABORT:
3661                   strcat (buf, ", abort");
3662                   break;
3663                 default:
3664                   warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3665                         e_flags & EF_IA_64_VMS_COMCOD);
3666                   strcat (buf, ", <unknown>");
3667                 }
3668             }
3669           break;
3670
3671         case EM_VAX:
3672           if ((e_flags & EF_VAX_NONPIC))
3673             strcat (buf, ", non-PIC");
3674           if ((e_flags & EF_VAX_DFLOAT))
3675             strcat (buf, ", D-Float");
3676           if ((e_flags & EF_VAX_GFLOAT))
3677             strcat (buf, ", G-Float");
3678           break;
3679
3680         case EM_VISIUM:
3681           if (e_flags & EF_VISIUM_ARCH_MCM)
3682             strcat (buf, ", mcm");
3683           else if (e_flags & EF_VISIUM_ARCH_MCM24)
3684             strcat (buf, ", mcm24");
3685           if (e_flags & EF_VISIUM_ARCH_GR6)
3686             strcat (buf, ", gr6");
3687           break;
3688
3689         case EM_RL78:
3690           switch (e_flags & E_FLAG_RL78_CPU_MASK)
3691             {
3692             case E_FLAG_RL78_ANY_CPU: break;
3693             case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3694             case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3695             case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3696             }
3697           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3698             strcat (buf, ", 64-bit doubles");
3699           break;
3700
3701         case EM_RX:
3702           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3703             strcat (buf, ", 64-bit doubles");
3704           if (e_flags & E_FLAG_RX_DSP)
3705             strcat (buf, ", dsp");
3706           if (e_flags & E_FLAG_RX_PID)
3707             strcat (buf, ", pid");
3708           if (e_flags & E_FLAG_RX_ABI)
3709             strcat (buf, ", RX ABI");
3710           if (e_flags & E_FLAG_RX_SINSNS_SET)
3711             strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3712                     ? ", uses String instructions" : ", bans String instructions");
3713           if (e_flags & E_FLAG_RX_V2)
3714             strcat (buf, ", V2");
3715           if (e_flags & E_FLAG_RX_V3)
3716             strcat (buf, ", V3");
3717           break;
3718
3719         case EM_S390:
3720           if (e_flags & EF_S390_HIGH_GPRS)
3721             strcat (buf, ", highgprs");
3722           break;
3723
3724         case EM_TI_C6000:
3725           if ((e_flags & EF_C6000_REL))
3726             strcat (buf, ", relocatable module");
3727           break;
3728
3729         case EM_MSP430:
3730           strcat (buf, _(": architecture variant: "));
3731           switch (e_flags & EF_MSP430_MACH)
3732             {
3733             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3734             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3735             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3736             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3737             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3738             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3739             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3740             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3741             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3742             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3743             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3744             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3745             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3746             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3747             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3748             default:
3749               strcat (buf, _(": unknown")); break;
3750             }
3751
3752           if (e_flags & ~ EF_MSP430_MACH)
3753             strcat (buf, _(": unknown extra flag bits also present"));
3754         }
3755     }
3756
3757   return buf;
3758 }
3759
3760 static const char *
3761 get_osabi_name (Filedata * filedata, unsigned int osabi)
3762 {
3763   static char buff[32];
3764
3765   switch (osabi)
3766     {
3767     case ELFOSABI_NONE:         return "UNIX - System V";
3768     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3769     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3770     case ELFOSABI_GNU:          return "UNIX - GNU";
3771     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3772     case ELFOSABI_AIX:          return "UNIX - AIX";
3773     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3774     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3775     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3776     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3777     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3778     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3779     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3780     case ELFOSABI_AROS:         return "AROS";
3781     case ELFOSABI_FENIXOS:      return "FenixOS";
3782     case ELFOSABI_CLOUDABI:     return "Nuxi CloudABI";
3783     case ELFOSABI_OPENVOS:      return "Stratus Technologies OpenVOS";
3784     default:
3785       if (osabi >= 64)
3786         switch (filedata->file_header.e_machine)
3787           {
3788           case EM_ARM:
3789             switch (osabi)
3790               {
3791               case ELFOSABI_ARM:        return "ARM";
3792               case ELFOSABI_ARM_FDPIC:  return "ARM FDPIC";
3793               default:
3794                 break;
3795               }
3796             break;
3797
3798           case EM_MSP430:
3799           case EM_MSP430_OLD:
3800           case EM_VISIUM:
3801             switch (osabi)
3802               {
3803               case ELFOSABI_STANDALONE: return _("Standalone App");
3804               default:
3805                 break;
3806               }
3807             break;
3808
3809           case EM_TI_C6000:
3810             switch (osabi)
3811               {
3812               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3813               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3814               default:
3815                 break;
3816               }
3817             break;
3818
3819           default:
3820             break;
3821           }
3822       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3823       return buff;
3824     }
3825 }
3826
3827 static const char *
3828 get_aarch64_segment_type (unsigned long type)
3829 {
3830   switch (type)
3831     {
3832     case PT_AARCH64_ARCHEXT:  return "AARCH64_ARCHEXT";
3833     default:                  return NULL;
3834     }
3835 }
3836
3837 static const char *
3838 get_arm_segment_type (unsigned long type)
3839 {
3840   switch (type)
3841     {
3842     case PT_ARM_EXIDX: return "EXIDX";
3843     default:           return NULL;
3844     }
3845 }
3846
3847 static const char *
3848 get_s390_segment_type (unsigned long type)
3849 {
3850   switch (type)
3851     {
3852     case PT_S390_PGSTE: return "S390_PGSTE";
3853     default:            return NULL;
3854     }
3855 }
3856
3857 static const char *
3858 get_mips_segment_type (unsigned long type)
3859 {
3860   switch (type)
3861     {
3862     case PT_MIPS_REGINFO:   return "REGINFO";
3863     case PT_MIPS_RTPROC:    return "RTPROC";
3864     case PT_MIPS_OPTIONS:   return "OPTIONS";
3865     case PT_MIPS_ABIFLAGS:  return "ABIFLAGS";
3866     default:                return NULL;
3867     }
3868 }
3869
3870 static const char *
3871 get_parisc_segment_type (unsigned long type)
3872 {
3873   switch (type)
3874     {
3875     case PT_HP_TLS:             return "HP_TLS";
3876     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3877     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3878     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3879     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3880     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3881     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3882     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3883     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3884     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3885     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3886     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3887     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3888     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3889     case PT_HP_STACK:           return "HP_STACK";
3890     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3891     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3892     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3893     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3894     default:                    return NULL;
3895     }
3896 }
3897
3898 static const char *
3899 get_ia64_segment_type (unsigned long type)
3900 {
3901   switch (type)
3902     {
3903     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3904     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3905     case PT_HP_TLS:             return "HP_TLS";
3906     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3907     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3908     case PT_IA_64_HP_STACK:     return "HP_STACK";
3909     default:                    return NULL;
3910     }
3911 }
3912
3913 static const char *
3914 get_tic6x_segment_type (unsigned long type)
3915 {
3916   switch (type)
3917     {
3918     case PT_C6000_PHATTR:  return "C6000_PHATTR";
3919     default:               return NULL;
3920     }
3921 }
3922
3923 static const char *
3924 get_solaris_segment_type (unsigned long type)
3925 {
3926   switch (type)
3927     {
3928     case 0x6464e550: return "PT_SUNW_UNWIND";
3929     case 0x6474e550: return "PT_SUNW_EH_FRAME";
3930     case 0x6ffffff7: return "PT_LOSUNW";
3931     case 0x6ffffffa: return "PT_SUNWBSS";
3932     case 0x6ffffffb: return "PT_SUNWSTACK";
3933     case 0x6ffffffc: return "PT_SUNWDTRACE";
3934     case 0x6ffffffd: return "PT_SUNWCAP";
3935     case 0x6fffffff: return "PT_HISUNW";
3936     default:         return NULL;
3937     }
3938 }
3939
3940 static const char *
3941 get_segment_type (Filedata * filedata, unsigned long p_type)
3942 {
3943   static char buff[32];
3944
3945   switch (p_type)
3946     {
3947     case PT_NULL:       return "NULL";
3948     case PT_LOAD:       return "LOAD";
3949     case PT_DYNAMIC:    return "DYNAMIC";
3950     case PT_INTERP:     return "INTERP";
3951     case PT_NOTE:       return "NOTE";
3952     case PT_SHLIB:      return "SHLIB";
3953     case PT_PHDR:       return "PHDR";
3954     case PT_TLS:        return "TLS";
3955     case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3956     case PT_GNU_STACK:  return "GNU_STACK";
3957     case PT_GNU_RELRO:  return "GNU_RELRO";
3958     case PT_GNU_PROPERTY: return "GNU_PROPERTY";
3959
3960     default:
3961       if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
3962         {
3963           sprintf (buff, "GNU_MBIND+%#lx",
3964                    p_type - PT_GNU_MBIND_LO);
3965         }
3966       else if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3967         {
3968           const char * result;
3969
3970           switch (filedata->file_header.e_machine)
3971             {
3972             case EM_AARCH64:
3973               result = get_aarch64_segment_type (p_type);
3974               break;
3975             case EM_ARM:
3976               result = get_arm_segment_type (p_type);
3977               break;
3978             case EM_MIPS:
3979             case EM_MIPS_RS3_LE:
3980               result = get_mips_segment_type (p_type);
3981               break;
3982             case EM_PARISC:
3983               result = get_parisc_segment_type (p_type);
3984               break;
3985             case EM_IA_64:
3986               result = get_ia64_segment_type (p_type);
3987               break;
3988             case EM_TI_C6000:
3989               result = get_tic6x_segment_type (p_type);
3990               break;
3991             case EM_S390:
3992             case EM_S390_OLD:
3993               result = get_s390_segment_type (p_type);
3994               break;
3995             default:
3996               result = NULL;
3997               break;
3998             }
3999
4000           if (result != NULL)
4001             return result;
4002
4003           sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
4004         }
4005       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
4006         {
4007           const char * result;
4008
4009           switch (filedata->file_header.e_machine)
4010             {
4011             case EM_PARISC:
4012               result = get_parisc_segment_type (p_type);
4013               break;
4014             case EM_IA_64:
4015               result = get_ia64_segment_type (p_type);
4016               break;
4017             default:
4018               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4019                 result = get_solaris_segment_type (p_type);
4020               else
4021                 result = NULL;
4022               break;
4023             }
4024
4025           if (result != NULL)
4026             return result;
4027
4028           sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
4029         }
4030       else
4031         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
4032
4033       return buff;
4034     }
4035 }
4036
4037 static const char *
4038 get_arc_section_type_name (unsigned int sh_type)
4039 {
4040   switch (sh_type)
4041     {
4042     case SHT_ARC_ATTRIBUTES:      return "ARC_ATTRIBUTES";
4043     default:
4044       break;
4045     }
4046   return NULL;
4047 }
4048
4049 static const char *
4050 get_mips_section_type_name (unsigned int sh_type)
4051 {
4052   switch (sh_type)
4053     {
4054     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
4055     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
4056     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
4057     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
4058     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
4059     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
4060     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
4061     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
4062     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
4063     case SHT_MIPS_RELD:          return "MIPS_RELD";
4064     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
4065     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
4066     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
4067     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
4068     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
4069     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
4070     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
4071     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
4072     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
4073     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
4074     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
4075     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
4076     case SHT_MIPS_LINE:          return "MIPS_LINE";
4077     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
4078     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
4079     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
4080     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
4081     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
4082     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
4083     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
4084     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
4085     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
4086     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
4087     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
4088     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
4089     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
4090     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
4091     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
4092     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
4093     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
4094     default:
4095       break;
4096     }
4097   return NULL;
4098 }
4099
4100 static const char *
4101 get_parisc_section_type_name (unsigned int sh_type)
4102 {
4103   switch (sh_type)
4104     {
4105     case SHT_PARISC_EXT:        return "PARISC_EXT";
4106     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
4107     case SHT_PARISC_DOC:        return "PARISC_DOC";
4108     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
4109     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
4110     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
4111     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
4112     default:                    return NULL;
4113     }
4114 }
4115
4116 static const char *
4117 get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
4118 {
4119   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
4120   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4121     return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
4122
4123   switch (sh_type)
4124     {
4125     case SHT_IA_64_EXT:                return "IA_64_EXT";
4126     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
4127     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
4128     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
4129     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4130     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
4131     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
4132     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
4133     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
4134     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
4135     default:
4136       break;
4137     }
4138   return NULL;
4139 }
4140
4141 static const char *
4142 get_x86_64_section_type_name (unsigned int sh_type)
4143 {
4144   switch (sh_type)
4145     {
4146     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
4147     default:                    return NULL;
4148     }
4149 }
4150
4151 static const char *
4152 get_aarch64_section_type_name (unsigned int sh_type)
4153 {
4154   switch (sh_type)
4155     {
4156     case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4157     default:                     return NULL;
4158     }
4159 }
4160
4161 static const char *
4162 get_arm_section_type_name (unsigned int sh_type)
4163 {
4164   switch (sh_type)
4165     {
4166     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
4167     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
4168     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
4169     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
4170     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
4171     default:                      return NULL;
4172     }
4173 }
4174
4175 static const char *
4176 get_tic6x_section_type_name (unsigned int sh_type)
4177 {
4178   switch (sh_type)
4179     {
4180     case SHT_C6000_UNWIND:      return "C6000_UNWIND";
4181     case SHT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
4182     case SHT_C6000_ATTRIBUTES:  return "C6000_ATTRIBUTES";
4183     case SHT_TI_ICODE:          return "TI_ICODE";
4184     case SHT_TI_XREF:           return "TI_XREF";
4185     case SHT_TI_HANDLER:        return "TI_HANDLER";
4186     case SHT_TI_INITINFO:       return "TI_INITINFO";
4187     case SHT_TI_PHATTRS:        return "TI_PHATTRS";
4188     default:                    return NULL;
4189     }
4190 }
4191
4192 static const char *
4193 get_msp430x_section_type_name (unsigned int sh_type)
4194 {
4195   switch (sh_type)
4196     {
4197     case SHT_MSP430_SEC_FLAGS:    return "MSP430_SEC_FLAGS";
4198     case SHT_MSP430_SYM_ALIASES:  return "MSP430_SYM_ALIASES";
4199     case SHT_MSP430_ATTRIBUTES:   return "MSP430_ATTRIBUTES";
4200     default:                      return NULL;
4201     }
4202 }
4203
4204 static const char *
4205 get_nfp_section_type_name (unsigned int sh_type)
4206 {
4207   switch (sh_type)
4208     {
4209     case SHT_NFP_MECONFIG:      return "NFP_MECONFIG";
4210     case SHT_NFP_INITREG:       return "NFP_INITREG";
4211     case SHT_NFP_UDEBUG:        return "NFP_UDEBUG";
4212     default:                    return NULL;
4213     }
4214 }
4215
4216 static const char *
4217 get_v850_section_type_name (unsigned int sh_type)
4218 {
4219   switch (sh_type)
4220     {
4221     case SHT_V850_SCOMMON:  return "V850 Small Common";
4222     case SHT_V850_TCOMMON:  return "V850 Tiny Common";
4223     case SHT_V850_ZCOMMON:  return "V850 Zero Common";
4224     case SHT_RENESAS_IOP:   return "RENESAS IOP";
4225     case SHT_RENESAS_INFO:  return "RENESAS INFO";
4226     default:                return NULL;
4227     }
4228 }
4229
4230 static const char *
4231 get_riscv_section_type_name (unsigned int sh_type)
4232 {
4233   switch (sh_type)
4234     {
4235     case SHT_RISCV_ATTRIBUTES:  return "RISCV_ATTRIBUTES";
4236     default: return NULL;
4237     }
4238 }
4239
4240 static const char *
4241 get_section_type_name (Filedata * filedata, unsigned int sh_type)
4242 {
4243   static char buff[32];
4244   const char * result;
4245
4246   switch (sh_type)
4247     {
4248     case SHT_NULL:              return "NULL";
4249     case SHT_PROGBITS:          return "PROGBITS";
4250     case SHT_SYMTAB:            return "SYMTAB";
4251     case SHT_STRTAB:            return "STRTAB";
4252     case SHT_RELA:              return "RELA";
4253     case SHT_HASH:              return "HASH";
4254     case SHT_DYNAMIC:           return "DYNAMIC";
4255     case SHT_NOTE:              return "NOTE";
4256     case SHT_NOBITS:            return "NOBITS";
4257     case SHT_REL:               return "REL";
4258     case SHT_SHLIB:             return "SHLIB";
4259     case SHT_DYNSYM:            return "DYNSYM";
4260     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
4261     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
4262     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
4263     case SHT_GNU_HASH:          return "GNU_HASH";
4264     case SHT_GROUP:             return "GROUP";
4265     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICES";
4266     case SHT_GNU_verdef:        return "VERDEF";
4267     case SHT_GNU_verneed:       return "VERNEED";
4268     case SHT_GNU_versym:        return "VERSYM";
4269     case 0x6ffffff0:            return "VERSYM";
4270     case 0x6ffffffc:            return "VERDEF";
4271     case 0x7ffffffd:            return "AUXILIARY";
4272     case 0x7fffffff:            return "FILTER";
4273     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
4274
4275     default:
4276       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4277         {
4278           switch (filedata->file_header.e_machine)
4279             {
4280             case EM_ARC:
4281             case EM_ARC_COMPACT:
4282             case EM_ARC_COMPACT2:
4283               result = get_arc_section_type_name (sh_type);
4284               break;
4285             case EM_MIPS:
4286             case EM_MIPS_RS3_LE:
4287               result = get_mips_section_type_name (sh_type);
4288               break;
4289             case EM_PARISC:
4290               result = get_parisc_section_type_name (sh_type);
4291               break;
4292             case EM_IA_64:
4293               result = get_ia64_section_type_name (filedata, sh_type);
4294               break;
4295             case EM_X86_64:
4296             case EM_L1OM:
4297             case EM_K1OM:
4298               result = get_x86_64_section_type_name (sh_type);
4299               break;
4300             case EM_AARCH64:
4301               result = get_aarch64_section_type_name (sh_type);
4302               break;
4303             case EM_ARM:
4304               result = get_arm_section_type_name (sh_type);
4305               break;
4306             case EM_TI_C6000:
4307               result = get_tic6x_section_type_name (sh_type);
4308               break;
4309             case EM_MSP430:
4310               result = get_msp430x_section_type_name (sh_type);
4311               break;
4312             case EM_NFP:
4313               result = get_nfp_section_type_name (sh_type);
4314               break;
4315             case EM_V800:
4316             case EM_V850:
4317             case EM_CYGNUS_V850:
4318               result = get_v850_section_type_name (sh_type);
4319               break;
4320             case EM_RISCV:
4321               result = get_riscv_section_type_name (sh_type);
4322               break;
4323             default:
4324               result = NULL;
4325               break;
4326             }
4327
4328           if (result != NULL)
4329             return result;
4330
4331           sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4332         }
4333       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4334         {
4335           switch (filedata->file_header.e_machine)
4336             {
4337             case EM_IA_64:
4338               result = get_ia64_section_type_name (filedata, sh_type);
4339               break;
4340             default:
4341               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4342                 result = get_solaris_section_type (sh_type);
4343               else
4344                 {
4345                   switch (sh_type)
4346                     {
4347                     case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4348                     case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4349                     case SHT_GNU_HASH: result = "GNU_HASH"; break;
4350                     case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4351                     default:
4352                       result = NULL;
4353                       break;
4354                     }
4355                 }
4356               break;
4357             }
4358
4359           if (result != NULL)
4360             return result;
4361
4362           sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4363         }
4364       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4365         {
4366           switch (filedata->file_header.e_machine)
4367             {
4368             case EM_V800:
4369             case EM_V850:
4370             case EM_CYGNUS_V850:
4371               result = get_v850_section_type_name (sh_type);
4372               break;
4373             default:
4374               result = NULL;
4375               break;
4376             }
4377
4378           if (result != NULL)
4379             return result;
4380
4381           sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4382         }
4383       else
4384         /* This message is probably going to be displayed in a 15
4385            character wide field, so put the hex value first.  */
4386         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4387
4388       return buff;
4389     }
4390 }
4391
4392 #define OPTION_DEBUG_DUMP       512
4393 #define OPTION_DYN_SYMS         513
4394 #define OPTION_DWARF_DEPTH      514
4395 #define OPTION_DWARF_START      515
4396 #define OPTION_DWARF_CHECK      516
4397
4398 static struct option options[] =
4399 {
4400   {"all",              no_argument, 0, 'a'},
4401   {"file-header",      no_argument, 0, 'h'},
4402   {"program-headers",  no_argument, 0, 'l'},
4403   {"headers",          no_argument, 0, 'e'},
4404   {"histogram",        no_argument, 0, 'I'},
4405   {"segments",         no_argument, 0, 'l'},
4406   {"sections",         no_argument, 0, 'S'},
4407   {"section-headers",  no_argument, 0, 'S'},
4408   {"section-groups",   no_argument, 0, 'g'},
4409   {"section-details",  no_argument, 0, 't'},
4410   {"full-section-name",no_argument, 0, 'N'},
4411   {"symbols",          no_argument, 0, 's'},
4412   {"syms",             no_argument, 0, 's'},
4413   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
4414   {"relocs",           no_argument, 0, 'r'},
4415   {"notes",            no_argument, 0, 'n'},
4416   {"dynamic",          no_argument, 0, 'd'},
4417   {"arch-specific",    no_argument, 0, 'A'},
4418   {"version-info",     no_argument, 0, 'V'},
4419   {"use-dynamic",      no_argument, 0, 'D'},
4420   {"unwind",           no_argument, 0, 'u'},
4421   {"archive-index",    no_argument, 0, 'c'},
4422   {"hex-dump",         required_argument, 0, 'x'},
4423   {"relocated-dump",   required_argument, 0, 'R'},
4424   {"string-dump",      required_argument, 0, 'p'},
4425   {"decompress",       no_argument, 0, 'z'},
4426 #ifdef SUPPORT_DISASSEMBLY
4427   {"instruction-dump", required_argument, 0, 'i'},
4428 #endif
4429   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
4430
4431   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
4432   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
4433   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
4434
4435   {"version",          no_argument, 0, 'v'},
4436   {"wide",             no_argument, 0, 'W'},
4437   {"help",             no_argument, 0, 'H'},
4438   {0,                  no_argument, 0, 0}
4439 };
4440
4441 static void
4442 usage (FILE * stream)
4443 {
4444   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4445   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4446   fprintf (stream, _(" Options are:\n\
4447   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4448   -h --file-header       Display the ELF file header\n\
4449   -l --program-headers   Display the program headers\n\
4450      --segments          An alias for --program-headers\n\
4451   -S --section-headers   Display the sections' header\n\
4452      --sections          An alias for --section-headers\n\
4453   -g --section-groups    Display the section groups\n\
4454   -t --section-details   Display the section details\n\
4455   -e --headers           Equivalent to: -h -l -S\n\
4456   -s --syms              Display the symbol table\n\
4457      --symbols           An alias for --syms\n\
4458   --dyn-syms             Display the dynamic symbol table\n\
4459   -n --notes             Display the core notes (if present)\n\
4460   -r --relocs            Display the relocations (if present)\n\
4461   -u --unwind            Display the unwind info (if present)\n\
4462   -d --dynamic           Display the dynamic section (if present)\n\
4463   -V --version-info      Display the version sections (if present)\n\
4464   -A --arch-specific     Display architecture specific information (if any)\n\
4465   -c --archive-index     Display the symbol/file index in an archive\n\
4466   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
4467   -x --hex-dump=<number|name>\n\
4468                          Dump the contents of section <number|name> as bytes\n\
4469   -p --string-dump=<number|name>\n\
4470                          Dump the contents of section <number|name> as strings\n\
4471   -R --relocated-dump=<number|name>\n\
4472                          Dump the contents of section <number|name> as relocated bytes\n\
4473   -z --decompress        Decompress section before dumping it\n\
4474   -w[lLiaprmfFsoRtUuTgAckK] or\n\
4475   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4476                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4477                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4478                =addr,=cu_index,=links,=follow-links]\n\
4479                          Display the contents of DWARF debug sections\n"));
4480   fprintf (stream, _("\
4481   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
4482   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
4483                          or deeper\n"));
4484 #ifdef SUPPORT_DISASSEMBLY
4485   fprintf (stream, _("\
4486   -i --instruction-dump=<number|name>\n\
4487                          Disassemble the contents of section <number|name>\n"));
4488 #endif
4489   fprintf (stream, _("\
4490   -I --histogram         Display histogram of bucket list lengths\n\
4491   -W --wide              Allow output width to exceed 80 characters\n\
4492   @<file>                Read options from <file>\n\
4493   -H --help              Display this information\n\
4494   -v --version           Display the version number of readelf\n"));
4495
4496   if (REPORT_BUGS_TO[0] && stream == stdout)
4497     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4498
4499   exit (stream == stdout ? 0 : 1);
4500 }
4501
4502 /* Record the fact that the user wants the contents of section number
4503    SECTION to be displayed using the method(s) encoded as flags bits
4504    in TYPE.  Note, TYPE can be zero if we are creating the array for
4505    the first time.  */
4506
4507 static void
4508 request_dump_bynumber (Filedata * filedata, unsigned int section, dump_type type)
4509 {
4510   if (section >= filedata->num_dump_sects)
4511     {
4512       dump_type * new_dump_sects;
4513
4514       new_dump_sects = (dump_type *) calloc (section + 1,
4515                                              sizeof (* new_dump_sects));
4516
4517       if (new_dump_sects == NULL)
4518         error (_("Out of memory allocating dump request table.\n"));
4519       else
4520         {
4521           if (filedata->dump_sects)
4522             {
4523               /* Copy current flag settings.  */
4524               memcpy (new_dump_sects, filedata->dump_sects,
4525                       filedata->num_dump_sects * sizeof (* new_dump_sects));
4526
4527               free (filedata->dump_sects);
4528             }
4529
4530           filedata->dump_sects = new_dump_sects;
4531           filedata->num_dump_sects = section + 1;
4532         }
4533     }
4534
4535   if (filedata->dump_sects)
4536     filedata->dump_sects[section] |= type;
4537 }
4538
4539 /* Request a dump by section name.  */
4540
4541 static void
4542 request_dump_byname (const char * section, dump_type type)
4543 {
4544   struct dump_list_entry * new_request;
4545
4546   new_request = (struct dump_list_entry *)
4547       malloc (sizeof (struct dump_list_entry));
4548   if (!new_request)
4549     error (_("Out of memory allocating dump request table.\n"));
4550
4551   new_request->name = strdup (section);
4552   if (!new_request->name)
4553     error (_("Out of memory allocating dump request table.\n"));
4554
4555   new_request->type = type;
4556
4557   new_request->next = dump_sects_byname;
4558   dump_sects_byname = new_request;
4559 }
4560
4561 static inline void
4562 request_dump (Filedata * filedata, dump_type type)
4563 {
4564   int section;
4565   char * cp;
4566
4567   do_dump++;
4568   section = strtoul (optarg, & cp, 0);
4569
4570   if (! *cp && section >= 0)
4571     request_dump_bynumber (filedata, section, type);
4572   else
4573     request_dump_byname (optarg, type);
4574 }
4575
4576 static void
4577 parse_args (Filedata * filedata, int argc, char ** argv)
4578 {
4579   int c;
4580
4581   if (argc < 2)
4582     usage (stderr);
4583
4584   while ((c = getopt_long
4585           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4586     {
4587       switch (c)
4588         {
4589         case 0:
4590           /* Long options.  */
4591           break;
4592         case 'H':
4593           usage (stdout);
4594           break;
4595
4596         case 'a':
4597           do_syms = TRUE;
4598           do_reloc = TRUE;
4599           do_unwind = TRUE;
4600           do_dynamic = TRUE;
4601           do_header = TRUE;
4602           do_sections = TRUE;
4603           do_section_groups = TRUE;
4604           do_segments = TRUE;
4605           do_version = TRUE;
4606           do_histogram = TRUE;
4607           do_arch = TRUE;
4608           do_notes = TRUE;
4609           break;
4610         case 'g':
4611           do_section_groups = TRUE;
4612           break;
4613         case 't':
4614         case 'N':
4615           do_sections = TRUE;
4616           do_section_details = TRUE;
4617           break;
4618         case 'e':
4619           do_header = TRUE;
4620           do_sections = TRUE;
4621           do_segments = TRUE;
4622           break;
4623         case 'A':
4624           do_arch = TRUE;
4625           break;
4626         case 'D':
4627           do_using_dynamic = TRUE;
4628           break;
4629         case 'r':
4630           do_reloc = TRUE;
4631           break;
4632         case 'u':
4633           do_unwind = TRUE;
4634           break;
4635         case 'h':
4636           do_header = TRUE;
4637           break;
4638         case 'l':
4639           do_segments = TRUE;
4640           break;
4641         case 's':
4642           do_syms = TRUE;
4643           break;
4644         case 'S':
4645           do_sections = TRUE;
4646           break;
4647         case 'd':
4648           do_dynamic = TRUE;
4649           break;
4650         case 'I':
4651           do_histogram = TRUE;
4652           break;
4653         case 'n':
4654           do_notes = TRUE;
4655           break;
4656         case 'c':
4657           do_archive_index = TRUE;
4658           break;
4659         case 'x':
4660           request_dump (filedata, HEX_DUMP);
4661           break;
4662         case 'p':
4663           request_dump (filedata, STRING_DUMP);
4664           break;
4665         case 'R':
4666           request_dump (filedata, RELOC_DUMP);
4667           break;
4668         case 'z':
4669           decompress_dumps = TRUE;
4670           break;
4671         case 'w':
4672           do_dump = TRUE;
4673           if (optarg == 0)
4674             {
4675               do_debugging = TRUE;
4676               dwarf_select_sections_all ();
4677             }
4678           else
4679             {
4680               do_debugging = FALSE;
4681               dwarf_select_sections_by_letters (optarg);
4682             }
4683           break;
4684         case OPTION_DEBUG_DUMP:
4685           do_dump = TRUE;
4686           if (optarg == 0)
4687             do_debugging = TRUE;
4688           else
4689             {
4690               do_debugging = FALSE;
4691               dwarf_select_sections_by_names (optarg);
4692             }
4693           break;
4694         case OPTION_DWARF_DEPTH:
4695           {
4696             char *cp;
4697
4698             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4699           }
4700           break;
4701         case OPTION_DWARF_START:
4702           {
4703             char *cp;
4704
4705             dwarf_start_die = strtoul (optarg, & cp, 0);
4706           }
4707           break;
4708         case OPTION_DWARF_CHECK:
4709           dwarf_check = TRUE;
4710           break;
4711         case OPTION_DYN_SYMS:
4712           do_dyn_syms = TRUE;
4713           break;
4714 #ifdef SUPPORT_DISASSEMBLY
4715         case 'i':
4716           request_dump (filedata, DISASS_DUMP);
4717           break;
4718 #endif
4719         case 'v':
4720           print_version (program_name);
4721           break;
4722         case 'V':
4723           do_version = TRUE;
4724           break;
4725         case 'W':
4726           do_wide = TRUE;
4727           break;
4728         default:
4729           /* xgettext:c-format */
4730           error (_("Invalid option '-%c'\n"), c);
4731           /* Fall through.  */
4732         case '?':
4733           usage (stderr);
4734         }
4735     }
4736
4737   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4738       && !do_segments && !do_header && !do_dump && !do_version
4739       && !do_histogram && !do_debugging && !do_arch && !do_notes
4740       && !do_section_groups && !do_archive_index
4741       && !do_dyn_syms)
4742     usage (stderr);
4743 }
4744
4745 static const char *
4746 get_elf_class (unsigned int elf_class)
4747 {
4748   static char buff[32];
4749
4750   switch (elf_class)
4751     {
4752     case ELFCLASSNONE: return _("none");
4753     case ELFCLASS32:   return "ELF32";
4754     case ELFCLASS64:   return "ELF64";
4755     default:
4756       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4757       return buff;
4758     }
4759 }
4760
4761 static const char *
4762 get_data_encoding (unsigned int encoding)
4763 {
4764   static char buff[32];
4765
4766   switch (encoding)
4767     {
4768     case ELFDATANONE: return _("none");
4769     case ELFDATA2LSB: return _("2's complement, little endian");
4770     case ELFDATA2MSB: return _("2's complement, big endian");
4771     default:
4772       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4773       return buff;
4774     }
4775 }
4776
4777 /* Decode the data held in 'filedata->file_header'.  */
4778
4779 static bfd_boolean
4780 process_file_header (Filedata * filedata)
4781 {
4782   Elf_Internal_Ehdr * header = & filedata->file_header;
4783
4784   if (   header->e_ident[EI_MAG0] != ELFMAG0
4785       || header->e_ident[EI_MAG1] != ELFMAG1
4786       || header->e_ident[EI_MAG2] != ELFMAG2
4787       || header->e_ident[EI_MAG3] != ELFMAG3)
4788     {
4789       error
4790         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4791       return FALSE;
4792     }
4793
4794   init_dwarf_regnames (header->e_machine);
4795
4796   if (do_header)
4797     {
4798       unsigned i;
4799
4800       printf (_("ELF Header:\n"));
4801       printf (_("  Magic:   "));
4802       for (i = 0; i < EI_NIDENT; i++)
4803         printf ("%2.2x ", header->e_ident[i]);
4804       printf ("\n");
4805       printf (_("  Class:                             %s\n"),
4806               get_elf_class (header->e_ident[EI_CLASS]));
4807       printf (_("  Data:                              %s\n"),
4808               get_data_encoding (header->e_ident[EI_DATA]));
4809       printf (_("  Version:                           %d%s\n"),
4810               header->e_ident[EI_VERSION],
4811               (header->e_ident[EI_VERSION] == EV_CURRENT
4812                ? _(" (current)")
4813                : (header->e_ident[EI_VERSION] != EV_NONE
4814                   ? _(" <unknown>")
4815                   : "")));
4816       printf (_("  OS/ABI:                            %s\n"),
4817               get_osabi_name (filedata, header->e_ident[EI_OSABI]));
4818       printf (_("  ABI Version:                       %d\n"),
4819               header->e_ident[EI_ABIVERSION]);
4820       printf (_("  Type:                              %s\n"),
4821               get_file_type (header->e_type));
4822       printf (_("  Machine:                           %s\n"),
4823               get_machine_name (header->e_machine));
4824       printf (_("  Version:                           0x%lx\n"),
4825               header->e_version);
4826
4827       printf (_("  Entry point address:               "));
4828       print_vma (header->e_entry, PREFIX_HEX);
4829       printf (_("\n  Start of program headers:          "));
4830       print_vma (header->e_phoff, DEC);
4831       printf (_(" (bytes into file)\n  Start of section headers:          "));
4832       print_vma (header->e_shoff, DEC);
4833       printf (_(" (bytes into file)\n"));
4834
4835       printf (_("  Flags:                             0x%lx%s\n"),
4836               header->e_flags,
4837               get_machine_flags (filedata, header->e_flags, header->e_machine));
4838       printf (_("  Size of this header:               %u (bytes)\n"),
4839               header->e_ehsize);
4840       printf (_("  Size of program headers:           %u (bytes)\n"),
4841               header->e_phentsize);
4842       printf (_("  Number of program headers:         %u"),
4843               header->e_phnum);
4844       if (filedata->section_headers != NULL
4845           && header->e_phnum == PN_XNUM
4846           && filedata->section_headers[0].sh_info != 0)
4847         {
4848           header->e_phnum = filedata->section_headers[0].sh_info;
4849           printf (" (%u)", header->e_phnum);
4850         }
4851       putc ('\n', stdout);
4852       printf (_("  Size of section headers:           %u (bytes)\n"),
4853               header->e_shentsize);
4854       printf (_("  Number of section headers:         %u"),
4855               header->e_shnum);
4856       if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
4857         {
4858           header->e_shnum = filedata->section_headers[0].sh_size;
4859           printf (" (%u)", header->e_shnum);
4860         }
4861       putc ('\n', stdout);
4862       printf (_("  Section header string table index: %u"),
4863               header->e_shstrndx);
4864       if (filedata->section_headers != NULL
4865           && header->e_shstrndx == (SHN_XINDEX & 0xffff))
4866         {
4867           header->e_shstrndx = filedata->section_headers[0].sh_link;
4868           printf (" (%u)", header->e_shstrndx);
4869         }
4870       if (header->e_shstrndx != SHN_UNDEF
4871           && header->e_shstrndx >= header->e_shnum)
4872         {
4873           header->e_shstrndx = SHN_UNDEF;
4874           printf (_(" <corrupt: out of range>"));
4875         }
4876       putc ('\n', stdout);
4877     }
4878
4879   if (filedata->section_headers != NULL)
4880     {
4881       if (header->e_phnum == PN_XNUM
4882           && filedata->section_headers[0].sh_info != 0)
4883         header->e_phnum = filedata->section_headers[0].sh_info;
4884       if (header->e_shnum == SHN_UNDEF)
4885         header->e_shnum = filedata->section_headers[0].sh_size;
4886       if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
4887         header->e_shstrndx = filedata->section_headers[0].sh_link;
4888       if (header->e_shstrndx >= header->e_shnum)
4889         header->e_shstrndx = SHN_UNDEF;
4890       free (filedata->section_headers);
4891       filedata->section_headers = NULL;
4892     }
4893
4894   return TRUE;
4895 }
4896
4897 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4898    Returns TRUE upon success, FALSE otherwise.  Loads 32-bit headers.  */
4899
4900 static bfd_boolean
4901 get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4902 {
4903   Elf32_External_Phdr * phdrs;
4904   Elf32_External_Phdr * external;
4905   Elf_Internal_Phdr *   internal;
4906   unsigned int i;
4907   unsigned int size = filedata->file_header.e_phentsize;
4908   unsigned int num  = filedata->file_header.e_phnum;
4909
4910   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4911   if (size == 0 || num == 0)
4912     return FALSE;
4913   if (size < sizeof * phdrs)
4914     {
4915       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4916       return FALSE;
4917     }
4918   if (size > sizeof * phdrs)
4919     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4920
4921   phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4922                                             size, num, _("program headers"));
4923   if (phdrs == NULL)
4924     return FALSE;
4925
4926   for (i = 0, internal = pheaders, external = phdrs;
4927        i < filedata->file_header.e_phnum;
4928        i++, internal++, external++)
4929     {
4930       internal->p_type   = BYTE_GET (external->p_type);
4931       internal->p_offset = BYTE_GET (external->p_offset);
4932       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4933       internal->p_paddr  = BYTE_GET (external->p_paddr);
4934       internal->p_filesz = BYTE_GET (external->p_filesz);
4935       internal->p_memsz  = BYTE_GET (external->p_memsz);
4936       internal->p_flags  = BYTE_GET (external->p_flags);
4937       internal->p_align  = BYTE_GET (external->p_align);
4938     }
4939
4940   free (phdrs);
4941   return TRUE;
4942 }
4943
4944 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4945    Returns TRUE upon success, FALSE otherwise.  Loads 64-bit headers.  */
4946
4947 static bfd_boolean
4948 get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4949 {
4950   Elf64_External_Phdr * phdrs;
4951   Elf64_External_Phdr * external;
4952   Elf_Internal_Phdr *   internal;
4953   unsigned int i;
4954   unsigned int size = filedata->file_header.e_phentsize;
4955   unsigned int num  = filedata->file_header.e_phnum;
4956
4957   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4958   if (size == 0 || num == 0)
4959     return FALSE;
4960   if (size < sizeof * phdrs)
4961     {
4962       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4963       return FALSE;
4964     }
4965   if (size > sizeof * phdrs)
4966     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4967
4968   phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4969                                             size, num, _("program headers"));
4970   if (!phdrs)
4971     return FALSE;
4972
4973   for (i = 0, internal = pheaders, external = phdrs;
4974        i < filedata->file_header.e_phnum;
4975        i++, internal++, external++)
4976     {
4977       internal->p_type   = BYTE_GET (external->p_type);
4978       internal->p_flags  = BYTE_GET (external->p_flags);
4979       internal->p_offset = BYTE_GET (external->p_offset);
4980       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4981       internal->p_paddr  = BYTE_GET (external->p_paddr);
4982       internal->p_filesz = BYTE_GET (external->p_filesz);
4983       internal->p_memsz  = BYTE_GET (external->p_memsz);
4984       internal->p_align  = BYTE_GET (external->p_align);
4985     }
4986
4987   free (phdrs);
4988   return TRUE;
4989 }
4990
4991 /* Returns TRUE if the program headers were read into `program_headers'.  */
4992
4993 static bfd_boolean
4994 get_program_headers (Filedata * filedata)
4995 {
4996   Elf_Internal_Phdr * phdrs;
4997
4998   /* Check cache of prior read.  */
4999   if (filedata->program_headers != NULL)
5000     return TRUE;
5001
5002   /* Be kind to memory checkers by looking for
5003      e_phnum values which we know must be invalid.  */
5004   if (filedata->file_header.e_phnum
5005       * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
5006       >= filedata->file_size)
5007     {
5008       error (_("Too many program headers - %#x - the file is not that big\n"),
5009              filedata->file_header.e_phnum);
5010       return FALSE;
5011     }
5012
5013   phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
5014                                          sizeof (Elf_Internal_Phdr));
5015   if (phdrs == NULL)
5016     {
5017       error (_("Out of memory reading %u program headers\n"),
5018              filedata->file_header.e_phnum);
5019       return FALSE;
5020     }
5021
5022   if (is_32bit_elf
5023       ? get_32bit_program_headers (filedata, phdrs)
5024       : get_64bit_program_headers (filedata, phdrs))
5025     {
5026       filedata->program_headers = phdrs;
5027       return TRUE;
5028     }
5029
5030   free (phdrs);
5031   return FALSE;
5032 }
5033
5034 /* Returns TRUE if the program headers were loaded.  */
5035
5036 static bfd_boolean
5037 process_program_headers (Filedata * filedata)
5038 {
5039   Elf_Internal_Phdr * segment;
5040   unsigned int i;
5041   Elf_Internal_Phdr * previous_load = NULL;
5042
5043   if (filedata->file_header.e_phnum == 0)
5044     {
5045       /* PR binutils/12467.  */
5046       if (filedata->file_header.e_phoff != 0)
5047         {
5048           warn (_("possibly corrupt ELF header - it has a non-zero program"
5049                   " header offset, but no program headers\n"));
5050           return FALSE;
5051         }
5052       else if (do_segments)
5053         printf (_("\nThere are no program headers in this file.\n"));
5054       return TRUE;
5055     }
5056
5057   if (do_segments && !do_header)
5058     {
5059       printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
5060       printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
5061       printf (ngettext ("There is %d program header, starting at offset %s\n",
5062                         "There are %d program headers, starting at offset %s\n",
5063                         filedata->file_header.e_phnum),
5064               filedata->file_header.e_phnum,
5065               bfd_vmatoa ("u", filedata->file_header.e_phoff));
5066     }
5067
5068   if (! get_program_headers (filedata))
5069     return TRUE;
5070
5071   if (do_segments)
5072     {
5073       if (filedata->file_header.e_phnum > 1)
5074         printf (_("\nProgram Headers:\n"));
5075       else
5076         printf (_("\nProgram Headers:\n"));
5077
5078       if (is_32bit_elf)
5079         printf
5080           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
5081       else if (do_wide)
5082         printf
5083           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
5084       else
5085         {
5086           printf
5087             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
5088           printf
5089             (_("                 FileSiz            MemSiz              Flags  Align\n"));
5090         }
5091     }
5092
5093   dynamic_addr = 0;
5094   dynamic_size = 0;
5095
5096   for (i = 0, segment = filedata->program_headers;
5097        i < filedata->file_header.e_phnum;
5098        i++, segment++)
5099     {
5100       if (do_segments)
5101         {
5102           printf ("  %-14.14s ", get_segment_type (filedata, segment->p_type));
5103
5104           if (is_32bit_elf)
5105             {
5106               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5107               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
5108               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
5109               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
5110               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
5111               printf ("%c%c%c ",
5112                       (segment->p_flags & PF_R ? 'R' : ' '),
5113                       (segment->p_flags & PF_W ? 'W' : ' '),
5114                       (segment->p_flags & PF_X ? 'E' : ' '));
5115               printf ("%#lx", (unsigned long) segment->p_align);
5116             }
5117           else if (do_wide)
5118             {
5119               if ((unsigned long) segment->p_offset == segment->p_offset)
5120                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5121               else
5122                 {
5123                   print_vma (segment->p_offset, FULL_HEX);
5124                   putchar (' ');
5125                 }
5126
5127               print_vma (segment->p_vaddr, FULL_HEX);
5128               putchar (' ');
5129               print_vma (segment->p_paddr, FULL_HEX);
5130               putchar (' ');
5131
5132               if ((unsigned long) segment->p_filesz == segment->p_filesz)
5133                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
5134               else
5135                 {
5136                   print_vma (segment->p_filesz, FULL_HEX);
5137                   putchar (' ');
5138                 }
5139
5140               if ((unsigned long) segment->p_memsz == segment->p_memsz)
5141                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5142               else
5143                 {
5144                   print_vma (segment->p_memsz, FULL_HEX);
5145                 }
5146
5147               printf (" %c%c%c ",
5148                       (segment->p_flags & PF_R ? 'R' : ' '),
5149                       (segment->p_flags & PF_W ? 'W' : ' '),
5150                       (segment->p_flags & PF_X ? 'E' : ' '));
5151
5152               if ((unsigned long) segment->p_align == segment->p_align)
5153                 printf ("%#lx", (unsigned long) segment->p_align);
5154               else
5155                 {
5156                   print_vma (segment->p_align, PREFIX_HEX);
5157                 }
5158             }
5159           else
5160             {
5161               print_vma (segment->p_offset, FULL_HEX);
5162               putchar (' ');
5163               print_vma (segment->p_vaddr, FULL_HEX);
5164               putchar (' ');
5165               print_vma (segment->p_paddr, FULL_HEX);
5166               printf ("\n                 ");
5167               print_vma (segment->p_filesz, FULL_HEX);
5168               putchar (' ');
5169               print_vma (segment->p_memsz, FULL_HEX);
5170               printf ("  %c%c%c    ",
5171                       (segment->p_flags & PF_R ? 'R' : ' '),
5172                       (segment->p_flags & PF_W ? 'W' : ' '),
5173                       (segment->p_flags & PF_X ? 'E' : ' '));
5174               print_vma (segment->p_align, PREFIX_HEX);
5175             }
5176
5177           putc ('\n', stdout);
5178         }
5179
5180       switch (segment->p_type)
5181         {
5182         case PT_LOAD:
5183 #if 0 /* Do not warn about out of order PT_LOAD segments.  Although officially
5184          required by the ELF standard, several programs, including the Linux
5185          kernel, make use of non-ordered segments.  */
5186           if (previous_load
5187               && previous_load->p_vaddr > segment->p_vaddr)
5188             error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5189 #endif
5190           if (segment->p_memsz < segment->p_filesz)
5191             error (_("the segment's file size is larger than its memory size\n"));
5192           previous_load = segment;
5193           break;
5194
5195         case PT_PHDR:
5196           /* PR 20815 - Verify that the program header is loaded into memory.  */
5197           if (i > 0 && previous_load != NULL)
5198             error (_("the PHDR segment must occur before any LOAD segment\n"));
5199           if (filedata->file_header.e_machine != EM_PARISC)
5200             {
5201               unsigned int j;
5202
5203               for (j = 1; j < filedata->file_header.e_phnum; j++)
5204                 if (filedata->program_headers[j].p_vaddr <= segment->p_vaddr
5205                     && (filedata->program_headers[j].p_vaddr
5206                         + filedata->program_headers[j].p_memsz)
5207                     >= (segment->p_vaddr + segment->p_filesz))
5208                   break;
5209               if (j == filedata->file_header.e_phnum)
5210                 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5211             }
5212           break;
5213
5214         case PT_DYNAMIC:
5215           if (dynamic_addr)
5216             error (_("more than one dynamic segment\n"));
5217
5218           /* By default, assume that the .dynamic section is the first
5219              section in the DYNAMIC segment.  */
5220           dynamic_addr = segment->p_offset;
5221           dynamic_size = segment->p_filesz;
5222
5223           /* Try to locate the .dynamic section. If there is
5224              a section header table, we can easily locate it.  */
5225           if (filedata->section_headers != NULL)
5226             {
5227               Elf_Internal_Shdr * sec;
5228
5229               sec = find_section (filedata, ".dynamic");
5230               if (sec == NULL || sec->sh_size == 0)
5231                 {
5232                   /* A corresponding .dynamic section is expected, but on
5233                      IA-64/OpenVMS it is OK for it to be missing.  */
5234                   if (!is_ia64_vms (filedata))
5235                     error (_("no .dynamic section in the dynamic segment\n"));
5236                   break;
5237                 }
5238
5239               if (sec->sh_type == SHT_NOBITS)
5240                 {
5241                   dynamic_size = 0;
5242                   break;
5243                 }
5244
5245               dynamic_addr = sec->sh_offset;
5246               dynamic_size = sec->sh_size;
5247
5248               if (dynamic_addr < segment->p_offset
5249                   || dynamic_addr > segment->p_offset + segment->p_filesz)
5250                 warn (_("the .dynamic section is not contained"
5251                         " within the dynamic segment\n"));
5252               else if (dynamic_addr > segment->p_offset)
5253                 warn (_("the .dynamic section is not the first section"
5254                         " in the dynamic segment.\n"));
5255             }
5256
5257           /* PR binutils/17512: Avoid corrupt dynamic section info in the
5258              segment.  Check this after matching against the section headers
5259              so we don't warn on debuginfo file (which have NOBITS .dynamic
5260              sections).  */
5261           if (dynamic_addr > filedata->file_size
5262               || dynamic_size > filedata->file_size - dynamic_addr)
5263             {
5264               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5265               dynamic_addr = dynamic_size = 0;
5266             }
5267           break;
5268
5269         case PT_INTERP:
5270           if (fseek (filedata->handle, archive_file_offset + (long) segment->p_offset,
5271                      SEEK_SET))
5272             error (_("Unable to find program interpreter name\n"));
5273           else
5274             {
5275               char fmt [32];
5276               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5277
5278               if (ret >= (int) sizeof (fmt) || ret < 0)
5279                 error (_("Internal error: failed to create format string to display program interpreter\n"));
5280
5281               program_interpreter[0] = 0;
5282               if (fscanf (filedata->handle, fmt, program_interpreter) <= 0)
5283                 error (_("Unable to read program interpreter name\n"));
5284
5285               if (do_segments)
5286                 printf (_("      [Requesting program interpreter: %s]\n"),
5287                     program_interpreter);
5288             }
5289           break;
5290         }
5291     }
5292
5293   if (do_segments
5294       && filedata->section_headers != NULL
5295       && filedata->string_table != NULL)
5296     {
5297       printf (_("\n Section to Segment mapping:\n"));
5298       printf (_("  Segment Sections...\n"));
5299
5300       for (i = 0; i < filedata->file_header.e_phnum; i++)
5301         {
5302           unsigned int j;
5303           Elf_Internal_Shdr * section;
5304
5305           segment = filedata->program_headers + i;
5306           section = filedata->section_headers + 1;
5307
5308           printf ("   %2.2d     ", i);
5309
5310           for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
5311             {
5312               if (!ELF_TBSS_SPECIAL (section, segment)
5313                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5314                 printf ("%s ", printable_section_name (filedata, section));
5315             }
5316
5317           putc ('\n',stdout);
5318         }
5319     }
5320
5321   return TRUE;
5322 }
5323
5324
5325 /* Find the file offset corresponding to VMA by using the program headers.  */
5326
5327 static long
5328 offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
5329 {
5330   Elf_Internal_Phdr * seg;
5331
5332   if (! get_program_headers (filedata))
5333     {
5334       warn (_("Cannot interpret virtual addresses without program headers.\n"));
5335       return (long) vma;
5336     }
5337
5338   for (seg = filedata->program_headers;
5339        seg < filedata->program_headers + filedata->file_header.e_phnum;
5340        ++seg)
5341     {
5342       if (seg->p_type != PT_LOAD)
5343         continue;
5344
5345       if (vma >= (seg->p_vaddr & -seg->p_align)
5346           && vma + size <= seg->p_vaddr + seg->p_filesz)
5347         return vma - seg->p_vaddr + seg->p_offset;
5348     }
5349
5350   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5351         (unsigned long) vma);
5352   return (long) vma;
5353 }
5354
5355
5356 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5357    If PROBE is true, this is just a probe and we do not generate any error
5358    messages if the load fails.  */
5359
5360 static bfd_boolean
5361 get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
5362 {
5363   Elf32_External_Shdr * shdrs;
5364   Elf_Internal_Shdr *   internal;
5365   unsigned int          i;
5366   unsigned int          size = filedata->file_header.e_shentsize;
5367   unsigned int          num = probe ? 1 : filedata->file_header.e_shnum;
5368
5369   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5370   if (size == 0 || num == 0)
5371     return FALSE;
5372   if (size < sizeof * shdrs)
5373     {
5374       if (! probe)
5375         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5376       return FALSE;
5377     }
5378   if (!probe && size > sizeof * shdrs)
5379     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5380
5381   shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
5382                                             size, num,
5383                                             probe ? NULL : _("section headers"));
5384   if (shdrs == NULL)
5385     return FALSE;
5386
5387   free (filedata->section_headers);
5388   filedata->section_headers = (Elf_Internal_Shdr *)
5389     cmalloc (num, sizeof (Elf_Internal_Shdr));
5390   if (filedata->section_headers == NULL)
5391     {
5392       if (!probe)
5393         error (_("Out of memory reading %u section headers\n"), num);
5394       free (shdrs);
5395       return FALSE;
5396     }
5397
5398   for (i = 0, internal = filedata->section_headers;
5399        i < num;
5400        i++, internal++)
5401     {
5402       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5403       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5404       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5405       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5406       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5407       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5408       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5409       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5410       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5411       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5412       if (!probe && internal->sh_link > num)
5413         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5414       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5415         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5416     }
5417
5418   free (shdrs);
5419   return TRUE;
5420 }
5421
5422 /* Like get_32bit_section_headers, except that it fetches 64-bit headers.  */
5423
5424 static bfd_boolean
5425 get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
5426 {
5427   Elf64_External_Shdr *  shdrs;
5428   Elf_Internal_Shdr *    internal;
5429   unsigned int           i;
5430   unsigned int           size = filedata->file_header.e_shentsize;
5431   unsigned int           num = probe ? 1 : filedata->file_header.e_shnum;
5432
5433   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5434   if (size == 0 || num == 0)
5435     return FALSE;
5436
5437   if (size < sizeof * shdrs)
5438     {
5439       if (! probe)
5440         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5441       return FALSE;
5442     }
5443
5444   if (! probe && size > sizeof * shdrs)
5445     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5446
5447   shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
5448                                             filedata->file_header.e_shoff,
5449                                             size, num,
5450                                             probe ? NULL : _("section headers"));
5451   if (shdrs == NULL)
5452     return FALSE;
5453
5454   free (filedata->section_headers);
5455   filedata->section_headers = (Elf_Internal_Shdr *)
5456     cmalloc (num, sizeof (Elf_Internal_Shdr));
5457   if (filedata->section_headers == NULL)
5458     {
5459       if (! probe)
5460         error (_("Out of memory reading %u section headers\n"), num);
5461       free (shdrs);
5462       return FALSE;
5463     }
5464
5465   for (i = 0, internal = filedata->section_headers;
5466        i < num;
5467        i++, internal++)
5468     {
5469       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5470       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5471       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5472       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5473       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5474       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5475       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5476       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5477       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5478       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5479       if (!probe && internal->sh_link > num)
5480         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5481       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5482         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5483     }
5484
5485   free (shdrs);
5486   return TRUE;
5487 }
5488
5489 static Elf_Internal_Sym *
5490 get_32bit_elf_symbols (Filedata *           filedata,
5491                        Elf_Internal_Shdr *  section,
5492                        unsigned long *      num_syms_return)
5493 {
5494   unsigned long number = 0;
5495   Elf32_External_Sym * esyms = NULL;
5496   Elf_External_Sym_Shndx * shndx = NULL;
5497   Elf_Internal_Sym * isyms = NULL;
5498   Elf_Internal_Sym * psym;
5499   unsigned int j;
5500   elf_section_list * entry;
5501
5502   if (section->sh_size == 0)
5503     {
5504       if (num_syms_return != NULL)
5505         * num_syms_return = 0;
5506       return NULL;
5507     }
5508
5509   /* Run some sanity checks first.  */
5510   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5511     {
5512       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5513              printable_section_name (filedata, section),
5514              (unsigned long) section->sh_entsize);
5515       goto exit_point;
5516     }
5517
5518   if (section->sh_size > filedata->file_size)
5519     {
5520       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5521              printable_section_name (filedata, section),
5522              (unsigned long) section->sh_size);
5523       goto exit_point;
5524     }
5525
5526   number = section->sh_size / section->sh_entsize;
5527
5528   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5529     {
5530       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5531              (unsigned long) section->sh_size,
5532              printable_section_name (filedata, section),
5533              (unsigned long) section->sh_entsize);
5534       goto exit_point;
5535     }
5536
5537   esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5538                                            section->sh_size, _("symbols"));
5539   if (esyms == NULL)
5540     goto exit_point;
5541
5542   shndx = NULL;
5543   for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5544     {
5545       if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5546         continue;
5547
5548       if (shndx != NULL)
5549         {
5550           error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5551           free (shndx);
5552         }
5553
5554       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5555                                                    entry->hdr->sh_offset,
5556                                                    1, entry->hdr->sh_size,
5557                                                    _("symbol table section indices"));
5558       if (shndx == NULL)
5559         goto exit_point;
5560
5561       /* PR17531: file: heap-buffer-overflow */
5562       if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5563         {
5564           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5565                  printable_section_name (filedata, entry->hdr),
5566                  (unsigned long) entry->hdr->sh_size,
5567                  (unsigned long) section->sh_size);
5568           goto exit_point;
5569         }
5570     }
5571
5572   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5573
5574   if (isyms == NULL)
5575     {
5576       error (_("Out of memory reading %lu symbols\n"),
5577              (unsigned long) number);
5578       goto exit_point;
5579     }
5580
5581   for (j = 0, psym = isyms; j < number; j++, psym++)
5582     {
5583       psym->st_name  = BYTE_GET (esyms[j].st_name);
5584       psym->st_value = BYTE_GET (esyms[j].st_value);
5585       psym->st_size  = BYTE_GET (esyms[j].st_size);
5586       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5587       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5588         psym->st_shndx
5589           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5590       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5591         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5592       psym->st_info  = BYTE_GET (esyms[j].st_info);
5593       psym->st_other = BYTE_GET (esyms[j].st_other);
5594     }
5595
5596  exit_point:
5597   free (shndx);
5598   free (esyms);
5599
5600   if (num_syms_return != NULL)
5601     * num_syms_return = isyms == NULL ? 0 : number;
5602
5603   return isyms;
5604 }
5605
5606 static Elf_Internal_Sym *
5607 get_64bit_elf_symbols (Filedata *           filedata,
5608                        Elf_Internal_Shdr *  section,
5609                        unsigned long *      num_syms_return)
5610 {
5611   unsigned long number = 0;
5612   Elf64_External_Sym * esyms = NULL;
5613   Elf_External_Sym_Shndx * shndx = NULL;
5614   Elf_Internal_Sym * isyms = NULL;
5615   Elf_Internal_Sym * psym;
5616   unsigned int j;
5617   elf_section_list * entry;
5618
5619   if (section->sh_size == 0)
5620     {
5621       if (num_syms_return != NULL)
5622         * num_syms_return = 0;
5623       return NULL;
5624     }
5625
5626   /* Run some sanity checks first.  */
5627   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5628     {
5629       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5630              printable_section_name (filedata, section),
5631              (unsigned long) section->sh_entsize);
5632       goto exit_point;
5633     }
5634
5635   if (section->sh_size > filedata->file_size)
5636     {
5637       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5638              printable_section_name (filedata, section),
5639              (unsigned long) section->sh_size);
5640       goto exit_point;
5641     }
5642
5643   number = section->sh_size / section->sh_entsize;
5644
5645   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5646     {
5647       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5648              (unsigned long) section->sh_size,
5649              printable_section_name (filedata, section),
5650              (unsigned long) section->sh_entsize);
5651       goto exit_point;
5652     }
5653
5654   esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5655                                            section->sh_size, _("symbols"));
5656   if (!esyms)
5657     goto exit_point;
5658
5659   shndx = NULL;
5660   for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5661     {
5662       if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5663         continue;
5664
5665       if (shndx != NULL)
5666         {
5667           error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5668           free (shndx);
5669         }
5670
5671       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5672                                                    entry->hdr->sh_offset,
5673                                                    1, entry->hdr->sh_size,
5674                                                    _("symbol table section indices"));
5675       if (shndx == NULL)
5676         goto exit_point;
5677
5678       /* PR17531: file: heap-buffer-overflow */
5679       if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5680         {
5681           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5682                  printable_section_name (filedata, entry->hdr),
5683                  (unsigned long) entry->hdr->sh_size,
5684                  (unsigned long) section->sh_size);
5685           goto exit_point;
5686         }
5687     }
5688
5689   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5690
5691   if (isyms == NULL)
5692     {
5693       error (_("Out of memory reading %lu symbols\n"),
5694              (unsigned long) number);
5695       goto exit_point;
5696     }
5697
5698   for (j = 0, psym = isyms; j < number; j++, psym++)
5699     {
5700       psym->st_name  = BYTE_GET (esyms[j].st_name);
5701       psym->st_info  = BYTE_GET (esyms[j].st_info);
5702       psym->st_other = BYTE_GET (esyms[j].st_other);
5703       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5704
5705       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5706         psym->st_shndx
5707           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5708       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5709         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5710
5711       psym->st_value = BYTE_GET (esyms[j].st_value);
5712       psym->st_size  = BYTE_GET (esyms[j].st_size);
5713     }
5714
5715  exit_point:
5716   free (shndx);
5717   free (esyms);
5718
5719   if (num_syms_return != NULL)
5720     * num_syms_return = isyms == NULL ? 0 : number;
5721
5722   return isyms;
5723 }
5724
5725 static const char *
5726 get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
5727 {
5728   static char buff[1024];
5729   char * p = buff;
5730   unsigned int field_size = is_32bit_elf ? 8 : 16;
5731   signed int sindex;
5732   unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5733   bfd_vma os_flags = 0;
5734   bfd_vma proc_flags = 0;
5735   bfd_vma unknown_flags = 0;
5736   static const struct
5737     {
5738       const char * str;
5739       unsigned int len;
5740     }
5741   flags [] =
5742     {
5743       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5744       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5745       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5746       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5747       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5748       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5749       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5750       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5751       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5752       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5753       /* IA-64 specific.  */
5754       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5755       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5756       /* IA-64 OpenVMS specific.  */
5757       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5758       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5759       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5760       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5761       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5762       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5763       /* Generic.  */
5764       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5765       /* SPARC specific.  */
5766       /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5767       /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5768       /* ARM specific.  */
5769       /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5770       /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5771       /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5772       /* GNU specific.  */
5773       /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5774       /* VLE specific.  */
5775       /* 25 */ { STRING_COMMA_LEN ("VLE") },
5776     };
5777
5778   if (do_section_details)
5779     {
5780       sprintf (buff, "[%*.*lx]: ",
5781                field_size, field_size, (unsigned long) sh_flags);
5782       p += field_size + 4;
5783     }
5784
5785   while (sh_flags)
5786     {
5787       bfd_vma flag;
5788
5789       flag = sh_flags & - sh_flags;
5790       sh_flags &= ~ flag;
5791
5792       if (do_section_details)
5793         {
5794           switch (flag)
5795             {
5796             case SHF_WRITE:             sindex = 0; break;
5797             case SHF_ALLOC:             sindex = 1; break;
5798             case SHF_EXECINSTR:         sindex = 2; break;
5799             case SHF_MERGE:             sindex = 3; break;
5800             case SHF_STRINGS:           sindex = 4; break;
5801             case SHF_INFO_LINK:         sindex = 5; break;
5802             case SHF_LINK_ORDER:        sindex = 6; break;
5803             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5804             case SHF_GROUP:             sindex = 8; break;
5805             case SHF_TLS:               sindex = 9; break;
5806             case SHF_EXCLUDE:           sindex = 18; break;
5807             case SHF_COMPRESSED:        sindex = 20; break;
5808             case SHF_GNU_MBIND:         sindex = 24; break;
5809
5810             default:
5811               sindex = -1;
5812               switch (filedata->file_header.e_machine)
5813                 {
5814                 case EM_IA_64:
5815                   if (flag == SHF_IA_64_SHORT)
5816                     sindex = 10;
5817                   else if (flag == SHF_IA_64_NORECOV)
5818                     sindex = 11;
5819 #ifdef BFD64
5820                   else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5821                     switch (flag)
5822                       {
5823                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5824                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5825                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5826                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5827                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5828                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5829                       default:                        break;
5830                       }
5831 #endif
5832                   break;
5833
5834                 case EM_386:
5835                 case EM_IAMCU:
5836                 case EM_X86_64:
5837                 case EM_L1OM:
5838                 case EM_K1OM:
5839                 case EM_OLD_SPARCV9:
5840                 case EM_SPARC32PLUS:
5841                 case EM_SPARCV9:
5842                 case EM_SPARC:
5843                   if (flag == SHF_ORDERED)
5844                     sindex = 19;
5845                   break;
5846
5847                 case EM_ARM:
5848                   switch (flag)
5849                     {
5850                     case SHF_ENTRYSECT: sindex = 21; break;
5851                     case SHF_ARM_PURECODE: sindex = 22; break;
5852                     case SHF_COMDEF: sindex = 23; break;
5853                     default: break;
5854                     }
5855                   break;
5856                 case EM_PPC:
5857                   if (flag == SHF_PPC_VLE)
5858                     sindex = 25;
5859                   break;
5860
5861                 default:
5862                   break;
5863                 }
5864             }
5865
5866           if (sindex != -1)
5867             {
5868               if (p != buff + field_size + 4)
5869                 {
5870                   if (size < (10 + 2))
5871                     {
5872                       warn (_("Internal error: not enough buffer room for section flag info"));
5873                       return _("<unknown>");
5874                     }
5875                   size -= 2;
5876                   *p++ = ',';
5877                   *p++ = ' ';
5878                 }
5879
5880               size -= flags [sindex].len;
5881               p = stpcpy (p, flags [sindex].str);
5882             }
5883           else if (flag & SHF_MASKOS)
5884             os_flags |= flag;
5885           else if (flag & SHF_MASKPROC)
5886             proc_flags |= flag;
5887           else
5888             unknown_flags |= flag;
5889         }
5890       else
5891         {
5892           switch (flag)
5893             {
5894             case SHF_WRITE:             *p = 'W'; break;
5895             case SHF_ALLOC:             *p = 'A'; break;
5896             case SHF_EXECINSTR:         *p = 'X'; break;
5897             case SHF_MERGE:             *p = 'M'; break;
5898             case SHF_STRINGS:           *p = 'S'; break;
5899             case SHF_INFO_LINK:         *p = 'I'; break;
5900             case SHF_LINK_ORDER:        *p = 'L'; break;
5901             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5902             case SHF_GROUP:             *p = 'G'; break;
5903             case SHF_TLS:               *p = 'T'; break;
5904             case SHF_EXCLUDE:           *p = 'E'; break;
5905             case SHF_COMPRESSED:        *p = 'C'; break;
5906             case SHF_GNU_MBIND:         *p = 'D'; break;
5907
5908             default:
5909               if ((filedata->file_header.e_machine == EM_X86_64
5910                    || filedata->file_header.e_machine == EM_L1OM
5911                    || filedata->file_header.e_machine == EM_K1OM)
5912                   && flag == SHF_X86_64_LARGE)
5913                 *p = 'l';
5914               else if (filedata->file_header.e_machine == EM_ARM
5915                        && flag == SHF_ARM_PURECODE)
5916                   *p = 'y';
5917               else if (filedata->file_header.e_machine == EM_PPC
5918                        && flag == SHF_PPC_VLE)
5919                   *p = 'v';
5920               else if (flag & SHF_MASKOS)
5921                 {
5922                   *p = 'o';
5923                   sh_flags &= ~ SHF_MASKOS;
5924                 }
5925               else if (flag & SHF_MASKPROC)
5926                 {
5927                   *p = 'p';
5928                   sh_flags &= ~ SHF_MASKPROC;
5929                 }
5930               else
5931                 *p = 'x';
5932               break;
5933             }
5934           p++;
5935         }
5936     }
5937
5938   if (do_section_details)
5939     {
5940       if (os_flags)
5941         {
5942           size -= 5 + field_size;
5943           if (p != buff + field_size + 4)
5944             {
5945               if (size < (2 + 1))
5946                 {
5947                   warn (_("Internal error: not enough buffer room for section flag info"));
5948                   return _("<unknown>");
5949                 }
5950               size -= 2;
5951               *p++ = ',';
5952               *p++ = ' ';
5953             }
5954           sprintf (p, "OS (%*.*lx)", field_size, field_size,
5955                    (unsigned long) os_flags);
5956           p += 5 + field_size;
5957         }
5958       if (proc_flags)
5959         {
5960           size -= 7 + field_size;
5961           if (p != buff + field_size + 4)
5962             {
5963               if (size < (2 + 1))
5964                 {
5965                   warn (_("Internal error: not enough buffer room for section flag info"));
5966                   return _("<unknown>");
5967                 }
5968               size -= 2;
5969               *p++ = ',';
5970               *p++ = ' ';
5971             }
5972           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5973                    (unsigned long) proc_flags);
5974           p += 7 + field_size;
5975         }
5976       if (unknown_flags)
5977         {
5978           size -= 10 + field_size;
5979           if (p != buff + field_size + 4)
5980             {
5981               if (size < (2 + 1))
5982                 {
5983                   warn (_("Internal error: not enough buffer room for section flag info"));
5984                   return _("<unknown>");
5985                 }
5986               size -= 2;
5987               *p++ = ',';
5988               *p++ = ' ';
5989             }
5990           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5991                    (unsigned long) unknown_flags);
5992           p += 10 + field_size;
5993         }
5994     }
5995
5996   *p = '\0';
5997   return buff;
5998 }
5999
6000 static unsigned int
6001 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
6002 {
6003   if (is_32bit_elf)
6004     {
6005       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
6006
6007       if (size < sizeof (* echdr))
6008         {
6009           error (_("Compressed section is too small even for a compression header\n"));
6010           return 0;
6011         }
6012
6013       chdr->ch_type = BYTE_GET (echdr->ch_type);
6014       chdr->ch_size = BYTE_GET (echdr->ch_size);
6015       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
6016       return sizeof (*echdr);
6017     }
6018   else
6019     {
6020       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
6021
6022       if (size < sizeof (* echdr))
6023         {
6024           error (_("Compressed section is too small even for a compression header\n"));
6025           return 0;
6026         }
6027
6028       chdr->ch_type = BYTE_GET (echdr->ch_type);
6029       chdr->ch_size = BYTE_GET (echdr->ch_size);
6030       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
6031       return sizeof (*echdr);
6032     }
6033 }
6034
6035 static bfd_boolean
6036 process_section_headers (Filedata * filedata)
6037 {
6038   Elf_Internal_Shdr * section;
6039   unsigned int i;
6040
6041   filedata->section_headers = NULL;
6042
6043   if (filedata->file_header.e_shnum == 0)
6044     {
6045       /* PR binutils/12467.  */
6046       if (filedata->file_header.e_shoff != 0)
6047         {
6048           warn (_("possibly corrupt ELF file header - it has a non-zero"
6049                   " section header offset, but no section headers\n"));
6050           return FALSE;
6051         }
6052       else if (do_sections)
6053         printf (_("\nThere are no sections in this file.\n"));
6054
6055       return TRUE;
6056     }
6057
6058   if (do_sections && !do_header)
6059     printf (ngettext ("There is %d section header, "
6060                       "starting at offset 0x%lx:\n",
6061                       "There are %d section headers, "
6062                       "starting at offset 0x%lx:\n",
6063                       filedata->file_header.e_shnum),
6064             filedata->file_header.e_shnum,
6065             (unsigned long) filedata->file_header.e_shoff);
6066
6067   if (is_32bit_elf)
6068     {
6069       if (! get_32bit_section_headers (filedata, FALSE))
6070         return FALSE;
6071     }
6072   else
6073     {
6074       if (! get_64bit_section_headers (filedata, FALSE))
6075         return FALSE;
6076     }
6077
6078   /* Read in the string table, so that we have names to display.  */
6079   if (filedata->file_header.e_shstrndx != SHN_UNDEF
6080        && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
6081     {
6082       section = filedata->section_headers + filedata->file_header.e_shstrndx;
6083
6084       if (section->sh_size != 0)
6085         {
6086           filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
6087                                                       1, section->sh_size,
6088                                                       _("string table"));
6089
6090           filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
6091         }
6092     }
6093
6094   /* Scan the sections for the dynamic symbol table
6095      and dynamic string table and debug sections.  */
6096   dynamic_symbols = NULL;
6097   dynamic_strings = NULL;
6098   dynamic_syminfo = NULL;
6099   symtab_shndx_list = NULL;
6100
6101   eh_addr_size = is_32bit_elf ? 4 : 8;
6102   switch (filedata->file_header.e_machine)
6103     {
6104     case EM_MIPS:
6105     case EM_MIPS_RS3_LE:
6106       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6107          FDE addresses.  However, the ABI also has a semi-official ILP32
6108          variant for which the normal FDE address size rules apply.
6109
6110          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6111          section, where XX is the size of longs in bits.  Unfortunately,
6112          earlier compilers provided no way of distinguishing ILP32 objects
6113          from LP64 objects, so if there's any doubt, we should assume that
6114          the official LP64 form is being used.  */
6115       if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
6116           && find_section (filedata, ".gcc_compiled_long32") == NULL)
6117         eh_addr_size = 8;
6118       break;
6119
6120     case EM_H8_300:
6121     case EM_H8_300H:
6122       switch (filedata->file_header.e_flags & EF_H8_MACH)
6123         {
6124         case E_H8_MACH_H8300:
6125         case E_H8_MACH_H8300HN:
6126         case E_H8_MACH_H8300SN:
6127         case E_H8_MACH_H8300SXN:
6128           eh_addr_size = 2;
6129           break;
6130         case E_H8_MACH_H8300H:
6131         case E_H8_MACH_H8300S:
6132         case E_H8_MACH_H8300SX:
6133           eh_addr_size = 4;
6134           break;
6135         }
6136       break;
6137
6138     case EM_M32C_OLD:
6139     case EM_M32C:
6140       switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
6141         {
6142         case EF_M32C_CPU_M16C:
6143           eh_addr_size = 2;
6144           break;
6145         }
6146       break;
6147     }
6148
6149 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
6150   do                                                                    \
6151     {                                                                   \
6152       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
6153       if (section->sh_entsize != expected_entsize)                      \
6154         {                                                               \
6155           char buf[40];                                                 \
6156           sprintf_vma (buf, section->sh_entsize);                       \
6157           /* Note: coded this way so that there is a single string for  \
6158              translation.  */ \
6159           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6160           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6161                    (unsigned) expected_entsize);                        \
6162           section->sh_entsize = expected_entsize;                       \
6163         }                                                               \
6164     }                                                                   \
6165   while (0)
6166
6167 #define CHECK_ENTSIZE(section, i, type)                                 \
6168   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
6169                         sizeof (Elf64_External_##type))
6170
6171   for (i = 0, section = filedata->section_headers;
6172        i < filedata->file_header.e_shnum;
6173        i++, section++)
6174     {
6175       char * name = SECTION_NAME (section);
6176
6177       if (section->sh_type == SHT_DYNSYM)
6178         {
6179           if (dynamic_symbols != NULL)
6180             {
6181               error (_("File contains multiple dynamic symbol tables\n"));
6182               continue;
6183             }
6184
6185           CHECK_ENTSIZE (section, i, Sym);
6186           dynamic_symbols = GET_ELF_SYMBOLS (filedata, section, & num_dynamic_syms);
6187         }
6188       else if (section->sh_type == SHT_STRTAB
6189                && streq (name, ".dynstr"))
6190         {
6191           if (dynamic_strings != NULL)
6192             {
6193               error (_("File contains multiple dynamic string tables\n"));
6194               continue;
6195             }
6196
6197           dynamic_strings = (char *) get_data (NULL, filedata, section->sh_offset,
6198                                                1, section->sh_size,
6199                                                _("dynamic strings"));
6200           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6201         }
6202       else if (section->sh_type == SHT_SYMTAB_SHNDX)
6203         {
6204           elf_section_list * entry = xmalloc (sizeof * entry);
6205
6206           entry->hdr = section;
6207           entry->next = symtab_shndx_list;
6208           symtab_shndx_list = entry;
6209         }
6210       else if (section->sh_type == SHT_SYMTAB)
6211         CHECK_ENTSIZE (section, i, Sym);
6212       else if (section->sh_type == SHT_GROUP)
6213         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6214       else if (section->sh_type == SHT_REL)
6215         CHECK_ENTSIZE (section, i, Rel);
6216       else if (section->sh_type == SHT_RELA)
6217         CHECK_ENTSIZE (section, i, Rela);
6218       else if ((do_debugging || do_debug_info || do_debug_abbrevs
6219                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6220                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6221                 || do_debug_str || do_debug_loc || do_debug_ranges
6222                 || do_debug_addr || do_debug_cu_index || do_debug_links)
6223                && (const_strneq (name, ".debug_")
6224                    || const_strneq (name, ".zdebug_")))
6225         {
6226           if (name[1] == 'z')
6227             name += sizeof (".zdebug_") - 1;
6228           else
6229             name += sizeof (".debug_") - 1;
6230
6231           if (do_debugging
6232               || (do_debug_info     && const_strneq (name, "info"))
6233               || (do_debug_info     && const_strneq (name, "types"))
6234               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
6235               || (do_debug_lines    && strcmp (name, "line") == 0)
6236               || (do_debug_lines    && const_strneq (name, "line."))
6237               || (do_debug_pubnames && const_strneq (name, "pubnames"))
6238               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6239               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6240               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6241               || (do_debug_aranges  && const_strneq (name, "aranges"))
6242               || (do_debug_ranges   && const_strneq (name, "ranges"))
6243               || (do_debug_ranges   && const_strneq (name, "rnglists"))
6244               || (do_debug_frames   && const_strneq (name, "frame"))
6245               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
6246               || (do_debug_macinfo  && const_strneq (name, "macro"))
6247               || (do_debug_str      && const_strneq (name, "str"))
6248               || (do_debug_loc      && const_strneq (name, "loc"))
6249               || (do_debug_loc      && const_strneq (name, "loclists"))
6250               || (do_debug_addr     && const_strneq (name, "addr"))
6251               || (do_debug_cu_index && const_strneq (name, "cu_index"))
6252               || (do_debug_cu_index && const_strneq (name, "tu_index"))
6253               )
6254             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6255         }
6256       /* Linkonce section to be combined with .debug_info at link time.  */
6257       else if ((do_debugging || do_debug_info)
6258                && const_strneq (name, ".gnu.linkonce.wi."))
6259         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6260       else if (do_debug_frames && streq (name, ".eh_frame"))
6261         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6262       else if (do_gdb_index && (streq (name, ".gdb_index")
6263                                 || streq (name, ".debug_names")))
6264         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6265       /* Trace sections for Itanium VMS.  */
6266       else if ((do_debugging || do_trace_info || do_trace_abbrevs
6267                 || do_trace_aranges)
6268                && const_strneq (name, ".trace_"))
6269         {
6270           name += sizeof (".trace_") - 1;
6271
6272           if (do_debugging
6273               || (do_trace_info     && streq (name, "info"))
6274               || (do_trace_abbrevs  && streq (name, "abbrev"))
6275               || (do_trace_aranges  && streq (name, "aranges"))
6276               )
6277             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6278         }
6279       else if ((do_debugging || do_debug_links)
6280                && (const_strneq (name, ".gnu_debuglink")
6281                    || const_strneq (name, ".gnu_debugaltlink")))
6282         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6283     }
6284
6285   if (! do_sections)
6286     return TRUE;
6287
6288   if (filedata->file_header.e_shnum > 1)
6289     printf (_("\nSection Headers:\n"));
6290   else
6291     printf (_("\nSection Header:\n"));
6292
6293   if (is_32bit_elf)
6294     {
6295       if (do_section_details)
6296         {
6297           printf (_("  [Nr] Name\n"));
6298           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
6299         }
6300       else
6301         printf
6302           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
6303     }
6304   else if (do_wide)
6305     {
6306       if (do_section_details)
6307         {
6308           printf (_("  [Nr] Name\n"));
6309           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
6310         }
6311       else
6312         printf
6313           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
6314     }
6315   else
6316     {
6317       if (do_section_details)
6318         {
6319           printf (_("  [Nr] Name\n"));
6320           printf (_("       Type              Address          Offset            Link\n"));
6321           printf (_("       Size              EntSize          Info              Align\n"));
6322         }
6323       else
6324         {
6325           printf (_("  [Nr] Name              Type             Address           Offset\n"));
6326           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
6327         }
6328     }
6329
6330   if (do_section_details)
6331     printf (_("       Flags\n"));
6332
6333   for (i = 0, section = filedata->section_headers;
6334        i < filedata->file_header.e_shnum;
6335        i++, section++)
6336     {
6337       /* Run some sanity checks on the section header.  */
6338
6339       /* Check the sh_link field.  */
6340       switch (section->sh_type)
6341         {
6342         case SHT_REL:
6343         case SHT_RELA:
6344           if (section->sh_link == 0
6345               && (filedata->file_header.e_type == ET_EXEC
6346                   || filedata->file_header.e_type == ET_DYN))
6347             /* A dynamic relocation section where all entries use a
6348                zero symbol index need not specify a symtab section.  */
6349             break;
6350           /* Fall through.  */
6351         case SHT_SYMTAB_SHNDX:
6352         case SHT_GROUP:
6353         case SHT_HASH:
6354         case SHT_GNU_HASH:
6355         case SHT_GNU_versym:
6356           if (section->sh_link == 0
6357               || section->sh_link >= filedata->file_header.e_shnum
6358               || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6359                   && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6360             warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6361                   i, section->sh_link);
6362           break;
6363
6364         case SHT_DYNAMIC:
6365         case SHT_SYMTAB:
6366         case SHT_DYNSYM:
6367         case SHT_GNU_verneed:
6368         case SHT_GNU_verdef:
6369         case SHT_GNU_LIBLIST:
6370           if (section->sh_link == 0
6371               || section->sh_link >= filedata->file_header.e_shnum
6372               || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6373             warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6374                   i, section->sh_link);
6375           break;
6376
6377         case SHT_INIT_ARRAY:
6378         case SHT_FINI_ARRAY:
6379         case SHT_PREINIT_ARRAY:
6380           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6381             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6382                   i, section->sh_link);
6383           break;
6384
6385         default:
6386           /* FIXME: Add support for target specific section types.  */
6387 #if 0     /* Currently we do not check other section types as there are too
6388              many special cases.  Stab sections for example have a type
6389              of SHT_PROGBITS but an sh_link field that links to the .stabstr
6390              section.  */
6391           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6392             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6393                   i, section->sh_link);
6394 #endif
6395           break;
6396         }
6397
6398       /* Check the sh_info field.  */
6399       switch (section->sh_type)
6400         {
6401         case SHT_REL:
6402         case SHT_RELA:
6403           if (section->sh_info == 0
6404               && (filedata->file_header.e_type == ET_EXEC
6405                   || filedata->file_header.e_type == ET_DYN))
6406             /* Dynamic relocations apply to segments, so they do not
6407                need to specify the section they relocate.  */
6408             break;
6409           if (section->sh_info == 0
6410               || section->sh_info >= filedata->file_header.e_shnum
6411               || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6412                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6413                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6414                   && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6415                   && filedata->section_headers[section->sh_info].sh_type != SHT_FINI_ARRAY
6416                   && filedata->section_headers[section->sh_info].sh_type != SHT_PREINIT_ARRAY
6417                   /* FIXME: Are other section types valid ?  */
6418                   && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6419             warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6420                   i, section->sh_info);
6421           break;
6422
6423         case SHT_DYNAMIC:
6424         case SHT_HASH:
6425         case SHT_SYMTAB_SHNDX:
6426         case SHT_INIT_ARRAY:
6427         case SHT_FINI_ARRAY:
6428         case SHT_PREINIT_ARRAY:
6429           if (section->sh_info != 0)
6430             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6431                   i, section->sh_info);
6432           break;
6433
6434         case SHT_GROUP:
6435         case SHT_SYMTAB:
6436         case SHT_DYNSYM:
6437           /* A symbol index - we assume that it is valid.  */
6438           break;
6439
6440         default:
6441           /* FIXME: Add support for target specific section types.  */
6442           if (section->sh_type == SHT_NOBITS)
6443             /* NOBITS section headers with non-zero sh_info fields can be
6444                created when a binary is stripped of everything but its debug
6445                information.  The stripped sections have their headers
6446                preserved but their types set to SHT_NOBITS.  So do not check
6447                this type of section.  */
6448             ;
6449           else if (section->sh_flags & SHF_INFO_LINK)
6450             {
6451               if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6452                 warn (_("[%2u]: Expected link to another section in info field"), i);
6453             }
6454           else if (section->sh_type < SHT_LOOS
6455                    && (section->sh_flags & SHF_GNU_MBIND) == 0
6456                    && section->sh_info != 0)
6457             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6458                   i, section->sh_info);
6459           break;
6460         }
6461
6462       /* Check the sh_size field.  */
6463       if (section->sh_size > filedata->file_size
6464           && section->sh_type != SHT_NOBITS
6465           && section->sh_type != SHT_NULL
6466           && section->sh_type < SHT_LOOS)
6467         warn (_("Size of section %u is larger than the entire file!\n"), i);
6468
6469       printf ("  [%2u] ", i);
6470       if (do_section_details)
6471         printf ("%s\n      ", printable_section_name (filedata, section));
6472       else
6473         print_symbol (-17, SECTION_NAME (section));
6474
6475       printf (do_wide ? " %-15s " : " %-15.15s ",
6476               get_section_type_name (filedata, section->sh_type));
6477
6478       if (is_32bit_elf)
6479         {
6480           const char * link_too_big = NULL;
6481
6482           print_vma (section->sh_addr, LONG_HEX);
6483
6484           printf ( " %6.6lx %6.6lx %2.2lx",
6485                    (unsigned long) section->sh_offset,
6486                    (unsigned long) section->sh_size,
6487                    (unsigned long) section->sh_entsize);
6488
6489           if (do_section_details)
6490             fputs ("  ", stdout);
6491           else
6492             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6493
6494           if (section->sh_link >= filedata->file_header.e_shnum)
6495             {
6496               link_too_big = "";
6497               /* The sh_link value is out of range.  Normally this indicates
6498                  an error but it can have special values in Solaris binaries.  */
6499               switch (filedata->file_header.e_machine)
6500                 {
6501                 case EM_386:
6502                 case EM_IAMCU:
6503                 case EM_X86_64:
6504                 case EM_L1OM:
6505                 case EM_K1OM:
6506                 case EM_OLD_SPARCV9:
6507                 case EM_SPARC32PLUS:
6508                 case EM_SPARCV9:
6509                 case EM_SPARC:
6510                   if (section->sh_link == (SHN_BEFORE & 0xffff))
6511                     link_too_big = "BEFORE";
6512                   else if (section->sh_link == (SHN_AFTER & 0xffff))
6513                     link_too_big = "AFTER";
6514                   break;
6515                 default:
6516                   break;
6517                 }
6518             }
6519
6520           if (do_section_details)
6521             {
6522               if (link_too_big != NULL && * link_too_big)
6523                 printf ("<%s> ", link_too_big);
6524               else
6525                 printf ("%2u ", section->sh_link);
6526               printf ("%3u %2lu\n", section->sh_info,
6527                       (unsigned long) section->sh_addralign);
6528             }
6529           else
6530             printf ("%2u %3u %2lu\n",
6531                     section->sh_link,
6532                     section->sh_info,
6533                     (unsigned long) section->sh_addralign);
6534
6535           if (link_too_big && ! * link_too_big)
6536             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6537                   i, section->sh_link);
6538         }
6539       else if (do_wide)
6540         {
6541           print_vma (section->sh_addr, LONG_HEX);
6542
6543           if ((long) section->sh_offset == section->sh_offset)
6544             printf (" %6.6lx", (unsigned long) section->sh_offset);
6545           else
6546             {
6547               putchar (' ');
6548               print_vma (section->sh_offset, LONG_HEX);
6549             }
6550
6551           if ((unsigned long) section->sh_size == section->sh_size)
6552             printf (" %6.6lx", (unsigned long) section->sh_size);
6553           else
6554             {
6555               putchar (' ');
6556               print_vma (section->sh_size, LONG_HEX);
6557             }
6558
6559           if ((unsigned long) section->sh_entsize == section->sh_entsize)
6560             printf (" %2.2lx", (unsigned long) section->sh_entsize);
6561           else
6562             {
6563               putchar (' ');
6564               print_vma (section->sh_entsize, LONG_HEX);
6565             }
6566
6567           if (do_section_details)
6568             fputs ("  ", stdout);
6569           else
6570             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6571
6572           printf ("%2u %3u ", section->sh_link, section->sh_info);
6573
6574           if ((unsigned long) section->sh_addralign == section->sh_addralign)
6575             printf ("%2lu\n", (unsigned long) section->sh_addralign);
6576           else
6577             {
6578               print_vma (section->sh_addralign, DEC);
6579               putchar ('\n');
6580             }
6581         }
6582       else if (do_section_details)
6583         {
6584           putchar (' ');
6585           print_vma (section->sh_addr, LONG_HEX);
6586           if ((long) section->sh_offset == section->sh_offset)
6587             printf ("  %16.16lx", (unsigned long) section->sh_offset);
6588           else
6589             {
6590               printf ("  ");
6591               print_vma (section->sh_offset, LONG_HEX);
6592             }
6593           printf ("  %u\n       ", section->sh_link);
6594           print_vma (section->sh_size, LONG_HEX);
6595           putchar (' ');
6596           print_vma (section->sh_entsize, LONG_HEX);
6597
6598           printf ("  %-16u  %lu\n",
6599                   section->sh_info,
6600                   (unsigned long) section->sh_addralign);
6601         }
6602       else
6603         {
6604           putchar (' ');
6605           print_vma (section->sh_addr, LONG_HEX);
6606           if ((long) section->sh_offset == section->sh_offset)
6607             printf ("  %8.8lx", (unsigned long) section->sh_offset);
6608           else
6609             {
6610               printf ("  ");
6611               print_vma (section->sh_offset, LONG_HEX);
6612             }
6613           printf ("\n       ");
6614           print_vma (section->sh_size, LONG_HEX);
6615           printf ("  ");
6616           print_vma (section->sh_entsize, LONG_HEX);
6617
6618           printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6619
6620           printf ("     %2u   %3u     %lu\n",
6621                   section->sh_link,
6622                   section->sh_info,
6623                   (unsigned long) section->sh_addralign);
6624         }
6625
6626       if (do_section_details)
6627         {
6628           printf ("       %s\n", get_elf_section_flags (filedata, section->sh_flags));
6629           if ((section->sh_flags & SHF_COMPRESSED) != 0)
6630             {
6631               /* Minimum section size is 12 bytes for 32-bit compression
6632                  header + 12 bytes for compressed data header.  */
6633               unsigned char buf[24];
6634
6635               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6636               if (get_data (&buf, filedata, section->sh_offset, 1,
6637                             sizeof (buf), _("compression header")))
6638                 {
6639                   Elf_Internal_Chdr chdr;
6640
6641                   (void) get_compression_header (&chdr, buf, sizeof (buf));
6642
6643                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6644                     printf ("       ZLIB, ");
6645                   else
6646                     printf (_("       [<unknown>: 0x%x], "),
6647                             chdr.ch_type);
6648                   print_vma (chdr.ch_size, LONG_HEX);
6649                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6650                 }
6651             }
6652         }
6653     }
6654
6655   if (!do_section_details)
6656     {
6657       /* The ordering of the letters shown here matches the ordering of the
6658          corresponding SHF_xxx values, and hence the order in which these
6659          letters will be displayed to the user.  */
6660       printf (_("Key to Flags:\n\
6661   W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6662   L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6663   C (compressed), x (unknown), o (OS specific), E (exclude),\n  "));
6664       if (filedata->file_header.e_machine == EM_X86_64
6665           || filedata->file_header.e_machine == EM_L1OM
6666           || filedata->file_header.e_machine == EM_K1OM)
6667         printf (_("l (large), "));
6668       else if (filedata->file_header.e_machine == EM_ARM)
6669         printf (_("y (purecode), "));
6670       else if (filedata->file_header.e_machine == EM_PPC)
6671         printf (_("v (VLE), "));
6672       printf ("p (processor specific)\n");
6673     }
6674
6675   return TRUE;
6676 }
6677
6678 static const char *
6679 get_group_flags (unsigned int flags)
6680 {
6681   static char buff[128];
6682
6683   if (flags == 0)
6684     return "";
6685   else if (flags == GRP_COMDAT)
6686     return "COMDAT ";
6687
6688   snprintf (buff, 14, _("[0x%x: "), flags);
6689
6690   flags &= ~ GRP_COMDAT;
6691   if (flags & GRP_MASKOS)
6692     {
6693       strcat (buff, "<OS specific>");
6694       flags &= ~ GRP_MASKOS;
6695     }
6696
6697   if (flags & GRP_MASKPROC)
6698     {
6699       strcat (buff, "<PROC specific>");
6700       flags &= ~ GRP_MASKPROC;
6701     }
6702
6703   if (flags)
6704     strcat (buff, "<unknown>");
6705
6706   strcat (buff, "]");
6707   return buff;
6708 }
6709
6710 static bfd_boolean
6711 process_section_groups (Filedata * filedata)
6712 {
6713   Elf_Internal_Shdr * section;
6714   unsigned int i;
6715   struct group * group;
6716   Elf_Internal_Shdr * symtab_sec;
6717   Elf_Internal_Shdr * strtab_sec;
6718   Elf_Internal_Sym * symtab;
6719   unsigned long num_syms;
6720   char * strtab;
6721   size_t strtab_size;
6722
6723   /* Don't process section groups unless needed.  */
6724   if (!do_unwind && !do_section_groups)
6725     return TRUE;
6726
6727   if (filedata->file_header.e_shnum == 0)
6728     {
6729       if (do_section_groups)
6730         printf (_("\nThere are no sections to group in this file.\n"));
6731
6732       return TRUE;
6733     }
6734
6735   if (filedata->section_headers == NULL)
6736     {
6737       error (_("Section headers are not available!\n"));
6738       /* PR 13622: This can happen with a corrupt ELF header.  */
6739       return FALSE;
6740     }
6741
6742   section_headers_groups = (struct group **) calloc (filedata->file_header.e_shnum,
6743                                                      sizeof (struct group *));
6744
6745   if (section_headers_groups == NULL)
6746     {
6747       error (_("Out of memory reading %u section group headers\n"),
6748              filedata->file_header.e_shnum);
6749       return FALSE;
6750     }
6751
6752   /* Scan the sections for the group section.  */
6753   group_count = 0;
6754   for (i = 0, section = filedata->section_headers;
6755        i < filedata->file_header.e_shnum;
6756        i++, section++)
6757     if (section->sh_type == SHT_GROUP)
6758       group_count++;
6759
6760   if (group_count == 0)
6761     {
6762       if (do_section_groups)
6763         printf (_("\nThere are no section groups in this file.\n"));
6764
6765       return TRUE;
6766     }
6767
6768   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6769
6770   if (section_groups == NULL)
6771     {
6772       error (_("Out of memory reading %lu groups\n"),
6773              (unsigned long) group_count);
6774       return FALSE;
6775     }
6776
6777   symtab_sec = NULL;
6778   strtab_sec = NULL;
6779   symtab = NULL;
6780   num_syms = 0;
6781   strtab = NULL;
6782   strtab_size = 0;
6783   for (i = 0, section = filedata->section_headers, group = section_groups;
6784        i < filedata->file_header.e_shnum;
6785        i++, section++)
6786     {
6787       if (section->sh_type == SHT_GROUP)
6788         {
6789           const char * name = printable_section_name (filedata, section);
6790           const char * group_name;
6791           unsigned char * start;
6792           unsigned char * indices;
6793           unsigned int entry, j, size;
6794           Elf_Internal_Shdr * sec;
6795           Elf_Internal_Sym * sym;
6796
6797           /* Get the symbol table.  */
6798           if (section->sh_link >= filedata->file_header.e_shnum
6799               || ((sec = filedata->section_headers + section->sh_link)->sh_type
6800                   != SHT_SYMTAB))
6801             {
6802               error (_("Bad sh_link in group section `%s'\n"), name);
6803               continue;
6804             }
6805
6806           if (symtab_sec != sec)
6807             {
6808               symtab_sec = sec;
6809               if (symtab)
6810                 free (symtab);
6811               symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
6812             }
6813
6814           if (symtab == NULL)
6815             {
6816               error (_("Corrupt header in group section `%s'\n"), name);
6817               continue;
6818             }
6819
6820           if (section->sh_info >= num_syms)
6821             {
6822               error (_("Bad sh_info in group section `%s'\n"), name);
6823               continue;
6824             }
6825
6826           sym = symtab + section->sh_info;
6827
6828           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6829             {
6830               if (sym->st_shndx == 0
6831                   || sym->st_shndx >= filedata->file_header.e_shnum)
6832                 {
6833                   error (_("Bad sh_info in group section `%s'\n"), name);
6834                   continue;
6835                 }
6836
6837               group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
6838               strtab_sec = NULL;
6839               if (strtab)
6840                 free (strtab);
6841               strtab = NULL;
6842               strtab_size = 0;
6843             }
6844           else
6845             {
6846               /* Get the string table.  */
6847               if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
6848                 {
6849                   strtab_sec = NULL;
6850                   if (strtab)
6851                     free (strtab);
6852                   strtab = NULL;
6853                   strtab_size = 0;
6854                 }
6855               else if (strtab_sec
6856                        != (sec = filedata->section_headers + symtab_sec->sh_link))
6857                 {
6858                   strtab_sec = sec;
6859                   if (strtab)
6860                     free (strtab);
6861
6862                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
6863                                               1, strtab_sec->sh_size,
6864                                               _("string table"));
6865                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6866                 }
6867               group_name = sym->st_name < strtab_size
6868                 ? strtab + sym->st_name : _("<corrupt>");
6869             }
6870
6871           /* PR 17531: file: loop.  */
6872           if (section->sh_entsize > section->sh_size)
6873             {
6874               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6875                      printable_section_name (filedata, section),
6876                      (unsigned long) section->sh_entsize,
6877                      (unsigned long) section->sh_size);
6878               break;
6879             }
6880
6881           start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
6882                                               1, section->sh_size,
6883                                               _("section data"));
6884           if (start == NULL)
6885             continue;
6886
6887           indices = start;
6888           size = (section->sh_size / section->sh_entsize) - 1;
6889           entry = byte_get (indices, 4);
6890           indices += 4;
6891
6892           if (do_section_groups)
6893             {
6894               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6895                       get_group_flags (entry), i, name, group_name, size);
6896
6897               printf (_("   [Index]    Name\n"));
6898             }
6899
6900           group->group_index = i;
6901
6902           for (j = 0; j < size; j++)
6903             {
6904               struct group_list * g;
6905
6906               entry = byte_get (indices, 4);
6907               indices += 4;
6908
6909               if (entry >= filedata->file_header.e_shnum)
6910                 {
6911                   static unsigned num_group_errors = 0;
6912
6913                   if (num_group_errors ++ < 10)
6914                     {
6915                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6916                              entry, i, filedata->file_header.e_shnum - 1);
6917                       if (num_group_errors == 10)
6918                         warn (_("Further error messages about overlarge group section indices suppressed\n"));
6919                     }
6920                   continue;
6921                 }
6922
6923               if (section_headers_groups [entry] != NULL)
6924                 {
6925                   if (entry)
6926                     {
6927                       static unsigned num_errs = 0;
6928
6929                       if (num_errs ++ < 10)
6930                         {
6931                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6932                                  entry, i,
6933                                  section_headers_groups [entry]->group_index);
6934                           if (num_errs == 10)
6935                             warn (_("Further error messages about already contained group sections suppressed\n"));
6936                         }
6937                       continue;
6938                     }
6939                   else
6940                     {
6941                       /* Intel C/C++ compiler may put section 0 in a
6942                          section group.  We just warn it the first time
6943                          and ignore it afterwards.  */
6944                       static bfd_boolean warned = FALSE;
6945                       if (!warned)
6946                         {
6947                           error (_("section 0 in group section [%5u]\n"),
6948                                  section_headers_groups [entry]->group_index);
6949                           warned = TRUE;
6950                         }
6951                     }
6952                 }
6953
6954               section_headers_groups [entry] = group;
6955
6956               if (do_section_groups)
6957                 {
6958                   sec = filedata->section_headers + entry;
6959                   printf ("   [%5u]   %s\n", entry, printable_section_name (filedata, sec));
6960                 }
6961
6962               g = (struct group_list *) xmalloc (sizeof (struct group_list));
6963               g->section_index = entry;
6964               g->next = group->root;
6965               group->root = g;
6966             }
6967
6968           if (start)
6969             free (start);
6970
6971           group++;
6972         }
6973     }
6974
6975   if (symtab)
6976     free (symtab);
6977   if (strtab)
6978     free (strtab);
6979   return TRUE;
6980 }
6981
6982 /* Data used to display dynamic fixups.  */
6983
6984 struct ia64_vms_dynfixup
6985 {
6986   bfd_vma needed_ident;         /* Library ident number.  */
6987   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
6988   bfd_vma fixup_needed;         /* Index of the library.  */
6989   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
6990   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
6991 };
6992
6993 /* Data used to display dynamic relocations.  */
6994
6995 struct ia64_vms_dynimgrela
6996 {
6997   bfd_vma img_rela_cnt;         /* Number of relocations.  */
6998   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
6999 };
7000
7001 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7002    library).  */
7003
7004 static bfd_boolean
7005 dump_ia64_vms_dynamic_fixups (Filedata *                  filedata,
7006                               struct ia64_vms_dynfixup *  fixup,
7007                               const char *                strtab,
7008                               unsigned int                strtab_sz)
7009 {
7010   Elf64_External_VMS_IMAGE_FIXUP * imfs;
7011   long i;
7012   const char * lib_name;
7013
7014   imfs = get_data (NULL, filedata, dynamic_addr + fixup->fixup_rela_off,
7015                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
7016                    _("dynamic section image fixups"));
7017   if (!imfs)
7018     return FALSE;
7019
7020   if (fixup->needed < strtab_sz)
7021     lib_name = strtab + fixup->needed;
7022   else
7023     {
7024       warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7025             (unsigned long) fixup->needed);
7026       lib_name = "???";
7027     }
7028   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7029           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
7030   printf
7031     (_("Seg Offset           Type                             SymVec DataType\n"));
7032
7033   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
7034     {
7035       unsigned int type;
7036       const char *rtype;
7037
7038       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
7039       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
7040       type = BYTE_GET (imfs [i].type);
7041       rtype = elf_ia64_reloc_type (type);
7042       if (rtype == NULL)
7043         printf (" 0x%08x                       ", type);
7044       else
7045         printf (" %-32s ", rtype);
7046       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
7047       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
7048     }
7049
7050   free (imfs);
7051   return TRUE;
7052 }
7053
7054 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
7055
7056 static bfd_boolean
7057 dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
7058 {
7059   Elf64_External_VMS_IMAGE_RELA *imrs;
7060   long i;
7061
7062   imrs = get_data (NULL, filedata, dynamic_addr + imgrela->img_rela_off,
7063                    1, imgrela->img_rela_cnt * sizeof (*imrs),
7064                    _("dynamic section image relocations"));
7065   if (!imrs)
7066     return FALSE;
7067
7068   printf (_("\nImage relocs\n"));
7069   printf
7070     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
7071
7072   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
7073     {
7074       unsigned int type;
7075       const char *rtype;
7076
7077       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
7078       printf ("%08" BFD_VMA_FMT "x ",
7079               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
7080       type = BYTE_GET (imrs [i].type);
7081       rtype = elf_ia64_reloc_type (type);
7082       if (rtype == NULL)
7083         printf ("0x%08x                      ", type);
7084       else
7085         printf ("%-31s ", rtype);
7086       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
7087       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
7088       printf ("%08" BFD_VMA_FMT "x\n",
7089               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
7090     }
7091
7092   free (imrs);
7093   return TRUE;
7094 }
7095
7096 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
7097
7098 static bfd_boolean
7099 process_ia64_vms_dynamic_relocs (Filedata * filedata)
7100 {
7101   struct ia64_vms_dynfixup fixup;
7102   struct ia64_vms_dynimgrela imgrela;
7103   Elf_Internal_Dyn *entry;
7104   bfd_vma strtab_off = 0;
7105   bfd_vma strtab_sz = 0;
7106   char *strtab = NULL;
7107   bfd_boolean res = TRUE;
7108
7109   memset (&fixup, 0, sizeof (fixup));
7110   memset (&imgrela, 0, sizeof (imgrela));
7111
7112   /* Note: the order of the entries is specified by the OpenVMS specs.  */
7113   for (entry = dynamic_section;
7114        entry < dynamic_section + dynamic_nent;
7115        entry++)
7116     {
7117       switch (entry->d_tag)
7118         {
7119         case DT_IA_64_VMS_STRTAB_OFFSET:
7120           strtab_off = entry->d_un.d_val;
7121           break;
7122         case DT_STRSZ:
7123           strtab_sz = entry->d_un.d_val;
7124           if (strtab == NULL)
7125             strtab = get_data (NULL, filedata, dynamic_addr + strtab_off,
7126                                1, strtab_sz, _("dynamic string section"));
7127           break;
7128
7129         case DT_IA_64_VMS_NEEDED_IDENT:
7130           fixup.needed_ident = entry->d_un.d_val;
7131           break;
7132         case DT_NEEDED:
7133           fixup.needed = entry->d_un.d_val;
7134           break;
7135         case DT_IA_64_VMS_FIXUP_NEEDED:
7136           fixup.fixup_needed = entry->d_un.d_val;
7137           break;
7138         case DT_IA_64_VMS_FIXUP_RELA_CNT:
7139           fixup.fixup_rela_cnt = entry->d_un.d_val;
7140           break;
7141         case DT_IA_64_VMS_FIXUP_RELA_OFF:
7142           fixup.fixup_rela_off = entry->d_un.d_val;
7143           if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7144             res = FALSE;
7145           break;
7146         case DT_IA_64_VMS_IMG_RELA_CNT:
7147           imgrela.img_rela_cnt = entry->d_un.d_val;
7148           break;
7149         case DT_IA_64_VMS_IMG_RELA_OFF:
7150           imgrela.img_rela_off = entry->d_un.d_val;
7151           if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7152             res = FALSE;
7153           break;
7154
7155         default:
7156           break;
7157         }
7158     }
7159
7160   if (strtab != NULL)
7161     free (strtab);
7162
7163   return res;
7164 }
7165
7166 static struct
7167 {
7168   const char * name;
7169   int reloc;
7170   int size;
7171   int rela;
7172 }
7173   dynamic_relocations [] =
7174 {
7175   { "REL", DT_REL, DT_RELSZ, FALSE },
7176   { "RELA", DT_RELA, DT_RELASZ, TRUE },
7177   { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7178 };
7179
7180 /* Process the reloc section.  */
7181
7182 static bfd_boolean
7183 process_relocs (Filedata * filedata)
7184 {
7185   unsigned long rel_size;
7186   unsigned long rel_offset;
7187
7188   if (!do_reloc)
7189     return TRUE;
7190
7191   if (do_using_dynamic)
7192     {
7193       int          is_rela;
7194       const char * name;
7195       bfd_boolean  has_dynamic_reloc;
7196       unsigned int i;
7197
7198       has_dynamic_reloc = FALSE;
7199
7200       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7201         {
7202           is_rela = dynamic_relocations [i].rela;
7203           name = dynamic_relocations [i].name;
7204           rel_size = dynamic_info [dynamic_relocations [i].size];
7205           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7206
7207           if (rel_size)
7208             has_dynamic_reloc = TRUE;
7209
7210           if (is_rela == UNKNOWN)
7211             {
7212               if (dynamic_relocations [i].reloc == DT_JMPREL)
7213                 switch (dynamic_info[DT_PLTREL])
7214                   {
7215                   case DT_REL:
7216                     is_rela = FALSE;
7217                     break;
7218                   case DT_RELA:
7219                     is_rela = TRUE;
7220                     break;
7221                   }
7222             }
7223
7224           if (rel_size)
7225             {
7226               printf
7227                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7228                  name, rel_offset, rel_size);
7229
7230               dump_relocations (filedata,
7231                                 offset_from_vma (filedata, rel_offset, rel_size),
7232                                 rel_size,
7233                                 dynamic_symbols, num_dynamic_syms,
7234                                 dynamic_strings, dynamic_strings_length,
7235                                 is_rela, TRUE /* is_dynamic */);
7236             }
7237         }
7238
7239       if (is_ia64_vms (filedata))
7240         if (process_ia64_vms_dynamic_relocs (filedata))
7241           has_dynamic_reloc = TRUE;
7242
7243       if (! has_dynamic_reloc)
7244         printf (_("\nThere are no dynamic relocations in this file.\n"));
7245     }
7246   else
7247     {
7248       Elf_Internal_Shdr * section;
7249       unsigned long i;
7250       bfd_boolean found = FALSE;
7251
7252       for (i = 0, section = filedata->section_headers;
7253            i < filedata->file_header.e_shnum;
7254            i++, section++)
7255         {
7256           if (   section->sh_type != SHT_RELA
7257               && section->sh_type != SHT_REL)
7258             continue;
7259
7260           rel_offset = section->sh_offset;
7261           rel_size   = section->sh_size;
7262
7263           if (rel_size)
7264             {
7265               Elf_Internal_Shdr * strsec;
7266               int is_rela;
7267               unsigned long num_rela;
7268
7269               printf (_("\nRelocation section "));
7270
7271               if (filedata->string_table == NULL)
7272                 printf ("%d", section->sh_name);
7273               else
7274                 printf ("'%s'", printable_section_name (filedata, section));
7275
7276               num_rela = rel_size / section->sh_entsize;
7277               printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7278                                 " at offset 0x%lx contains %lu entries:\n",
7279                                 num_rela),
7280                       rel_offset, num_rela);
7281
7282               is_rela = section->sh_type == SHT_RELA;
7283
7284               if (section->sh_link != 0
7285                   && section->sh_link < filedata->file_header.e_shnum)
7286                 {
7287                   Elf_Internal_Shdr * symsec;
7288                   Elf_Internal_Sym *  symtab;
7289                   unsigned long nsyms;
7290                   unsigned long strtablen = 0;
7291                   char * strtab = NULL;
7292
7293                   symsec = filedata->section_headers + section->sh_link;
7294                   if (symsec->sh_type != SHT_SYMTAB
7295                       && symsec->sh_type != SHT_DYNSYM)
7296                     continue;
7297
7298                   symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
7299
7300                   if (symtab == NULL)
7301                     continue;
7302
7303                   if (symsec->sh_link != 0
7304                       && symsec->sh_link < filedata->file_header.e_shnum)
7305                     {
7306                       strsec = filedata->section_headers + symsec->sh_link;
7307
7308                       strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7309                                                   1, strsec->sh_size,
7310                                                   _("string table"));
7311                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
7312                     }
7313
7314                   dump_relocations (filedata, rel_offset, rel_size,
7315                                     symtab, nsyms, strtab, strtablen,
7316                                     is_rela,
7317                                     symsec->sh_type == SHT_DYNSYM);
7318                   if (strtab)
7319                     free (strtab);
7320                   free (symtab);
7321                 }
7322               else
7323                 dump_relocations (filedata, rel_offset, rel_size,
7324                                   NULL, 0, NULL, 0, is_rela,
7325                                   FALSE /* is_dynamic */);
7326
7327               found = TRUE;
7328             }
7329         }
7330
7331       if (! found)
7332         {
7333           /* Users sometimes forget the -D option, so try to be helpful.  */
7334           for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7335             {
7336               if (dynamic_info [dynamic_relocations [i].size])
7337                 {
7338                   printf (_("\nThere are no static relocations in this file."));
7339                   printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7340
7341                   break;
7342                 }
7343             }
7344           if (i == ARRAY_SIZE (dynamic_relocations))
7345             printf (_("\nThere are no relocations in this file.\n"));
7346         }
7347     }
7348
7349   return TRUE;
7350 }
7351
7352 /* An absolute address consists of a section and an offset.  If the
7353    section is NULL, the offset itself is the address, otherwise, the
7354    address equals to LOAD_ADDRESS(section) + offset.  */
7355
7356 struct absaddr
7357 {
7358   unsigned short section;
7359   bfd_vma offset;
7360 };
7361
7362 #define ABSADDR(a) \
7363   ((a).section \
7364    ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7365    : (a).offset)
7366
7367 /* Find the nearest symbol at or below ADDR.  Returns the symbol
7368    name, if found, and the offset from the symbol to ADDR.  */
7369
7370 static void
7371 find_symbol_for_address (Filedata *          filedata,
7372                          Elf_Internal_Sym *  symtab,
7373                          unsigned long       nsyms,
7374                          const char *        strtab,
7375                          unsigned long       strtab_size,
7376                          struct absaddr      addr,
7377                          const char **       symname,
7378                          bfd_vma *           offset)
7379 {
7380   bfd_vma dist = 0x100000;
7381   Elf_Internal_Sym * sym;
7382   Elf_Internal_Sym * beg;
7383   Elf_Internal_Sym * end;
7384   Elf_Internal_Sym * best = NULL;
7385
7386   REMOVE_ARCH_BITS (addr.offset);
7387   beg = symtab;
7388   end = symtab + nsyms;
7389
7390   while (beg < end)
7391     {
7392       bfd_vma value;
7393
7394       sym = beg + (end - beg) / 2;
7395
7396       value = sym->st_value;
7397       REMOVE_ARCH_BITS (value);
7398
7399       if (sym->st_name != 0
7400           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7401           && addr.offset >= value
7402           && addr.offset - value < dist)
7403         {
7404           best = sym;
7405           dist = addr.offset - value;
7406           if (!dist)
7407             break;
7408         }
7409
7410       if (addr.offset < value)
7411         end = sym;
7412       else
7413         beg = sym + 1;
7414     }
7415
7416   if (best)
7417     {
7418       *symname = (best->st_name >= strtab_size
7419                   ? _("<corrupt>") : strtab + best->st_name);
7420       *offset = dist;
7421       return;
7422     }
7423
7424   *symname = NULL;
7425   *offset = addr.offset;
7426 }
7427
7428 static /* signed */ int
7429 symcmp (const void *p, const void *q)
7430 {
7431   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7432   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7433
7434   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7435 }
7436
7437 /* Process the unwind section.  */
7438
7439 #include "unwind-ia64.h"
7440
7441 struct ia64_unw_table_entry
7442 {
7443   struct absaddr start;
7444   struct absaddr end;
7445   struct absaddr info;
7446 };
7447
7448 struct ia64_unw_aux_info
7449 {
7450   struct ia64_unw_table_entry * table;          /* Unwind table.  */
7451   unsigned long                 table_len;      /* Length of unwind table.  */
7452   unsigned char *               info;           /* Unwind info.  */
7453   unsigned long                 info_size;      /* Size of unwind info.  */
7454   bfd_vma                       info_addr;      /* Starting address of unwind info.  */
7455   bfd_vma                       seg_base;       /* Starting address of segment.  */
7456   Elf_Internal_Sym *            symtab;         /* The symbol table.  */
7457   unsigned long                 nsyms;          /* Number of symbols.  */
7458   Elf_Internal_Sym *            funtab;         /* Sorted table of STT_FUNC symbols.  */
7459   unsigned long                 nfuns;          /* Number of entries in funtab.  */
7460   char *                        strtab;         /* The string table.  */
7461   unsigned long                 strtab_size;    /* Size of string table.  */
7462 };
7463
7464 static bfd_boolean
7465 dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7466 {
7467   struct ia64_unw_table_entry * tp;
7468   unsigned long j, nfuns;
7469   int in_body;
7470   bfd_boolean res = TRUE;
7471
7472   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7473   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7474     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7475       aux->funtab[nfuns++] = aux->symtab[j];
7476   aux->nfuns = nfuns;
7477   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7478
7479   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7480     {
7481       bfd_vma stamp;
7482       bfd_vma offset;
7483       const unsigned char * dp;
7484       const unsigned char * head;
7485       const unsigned char * end;
7486       const char * procname;
7487
7488       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7489                                aux->strtab_size, tp->start, &procname, &offset);
7490
7491       fputs ("\n<", stdout);
7492
7493       if (procname)
7494         {
7495           fputs (procname, stdout);
7496
7497           if (offset)
7498             printf ("+%lx", (unsigned long) offset);
7499         }
7500
7501       fputs (">: [", stdout);
7502       print_vma (tp->start.offset, PREFIX_HEX);
7503       fputc ('-', stdout);
7504       print_vma (tp->end.offset, PREFIX_HEX);
7505       printf ("], info at +0x%lx\n",
7506               (unsigned long) (tp->info.offset - aux->seg_base));
7507
7508       /* PR 17531: file: 86232b32.  */
7509       if (aux->info == NULL)
7510         continue;
7511
7512       /* PR 17531: file: 0997b4d1.  */
7513       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7514         {
7515           warn (_("Invalid offset %lx in table entry %ld\n"),
7516                 (long) tp->info.offset, (long) (tp - aux->table));
7517           res = FALSE;
7518           continue;
7519         }
7520
7521       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7522       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7523
7524       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7525               (unsigned) UNW_VER (stamp),
7526               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7527               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7528               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7529               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7530
7531       if (UNW_VER (stamp) != 1)
7532         {
7533           printf (_("\tUnknown version.\n"));
7534           continue;
7535         }
7536
7537       in_body = 0;
7538       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7539       /* PR 17531: file: 16ceda89.  */
7540       if (end > aux->info + aux->info_size)
7541         end = aux->info + aux->info_size;
7542       for (dp = head + 8; dp < end;)
7543         dp = unw_decode (dp, in_body, & in_body, end);
7544     }
7545
7546   free (aux->funtab);
7547
7548   return res;
7549 }
7550
7551 static bfd_boolean
7552 slurp_ia64_unwind_table (Filedata *                  filedata,
7553                          struct ia64_unw_aux_info *  aux,
7554                          Elf_Internal_Shdr *         sec)
7555 {
7556   unsigned long size, nrelas, i;
7557   Elf_Internal_Phdr * seg;
7558   struct ia64_unw_table_entry * tep;
7559   Elf_Internal_Shdr * relsec;
7560   Elf_Internal_Rela * rela;
7561   Elf_Internal_Rela * rp;
7562   unsigned char * table;
7563   unsigned char * tp;
7564   Elf_Internal_Sym * sym;
7565   const char * relname;
7566
7567   aux->table_len = 0;
7568
7569   /* First, find the starting address of the segment that includes
7570      this section: */
7571
7572   if (filedata->file_header.e_phnum)
7573     {
7574       if (! get_program_headers (filedata))
7575           return FALSE;
7576
7577       for (seg = filedata->program_headers;
7578            seg < filedata->program_headers + filedata->file_header.e_phnum;
7579            ++seg)
7580         {
7581           if (seg->p_type != PT_LOAD)
7582             continue;
7583
7584           if (sec->sh_addr >= seg->p_vaddr
7585               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7586             {
7587               aux->seg_base = seg->p_vaddr;
7588               break;
7589             }
7590         }
7591     }
7592
7593   /* Second, build the unwind table from the contents of the unwind section:  */
7594   size = sec->sh_size;
7595   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7596                                       _("unwind table"));
7597   if (!table)
7598     return FALSE;
7599
7600   aux->table_len = size / (3 * eh_addr_size);
7601   aux->table = (struct ia64_unw_table_entry *)
7602     xcmalloc (aux->table_len, sizeof (aux->table[0]));
7603   tep = aux->table;
7604
7605   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7606     {
7607       tep->start.section = SHN_UNDEF;
7608       tep->end.section   = SHN_UNDEF;
7609       tep->info.section  = SHN_UNDEF;
7610       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7611       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7612       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7613       tep->start.offset += aux->seg_base;
7614       tep->end.offset   += aux->seg_base;
7615       tep->info.offset  += aux->seg_base;
7616     }
7617   free (table);
7618
7619   /* Third, apply any relocations to the unwind table:  */
7620   for (relsec = filedata->section_headers;
7621        relsec < filedata->section_headers + filedata->file_header.e_shnum;
7622        ++relsec)
7623     {
7624       if (relsec->sh_type != SHT_RELA
7625           || relsec->sh_info >= filedata->file_header.e_shnum
7626           || filedata->section_headers + relsec->sh_info != sec)
7627         continue;
7628
7629       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7630                               & rela, & nrelas))
7631         {
7632           free (aux->table);
7633           aux->table = NULL;
7634           aux->table_len = 0;
7635           return FALSE;
7636         }
7637
7638       for (rp = rela; rp < rela + nrelas; ++rp)
7639         {
7640           unsigned int sym_ndx;
7641           unsigned int r_type = get_reloc_type (filedata, rp->r_info);
7642           relname = elf_ia64_reloc_type (r_type);
7643
7644           /* PR 17531: file: 9fa67536.  */
7645           if (relname == NULL)
7646             {
7647               warn (_("Skipping unknown relocation type: %u\n"), r_type);
7648               continue;
7649             }
7650
7651           if (! const_strneq (relname, "R_IA64_SEGREL"))
7652             {
7653               warn (_("Skipping unexpected relocation type: %s\n"), relname);
7654               continue;
7655             }
7656
7657           i = rp->r_offset / (3 * eh_addr_size);
7658
7659           /* PR 17531: file: 5bc8d9bf.  */
7660           if (i >= aux->table_len)
7661             {
7662               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7663               continue;
7664             }
7665
7666           sym_ndx = get_reloc_symindex (rp->r_info);
7667           if (sym_ndx >= aux->nsyms)
7668             {
7669               warn (_("Skipping reloc with invalid symbol index: %u\n"),
7670                     sym_ndx);
7671               continue;
7672             }
7673           sym = aux->symtab + sym_ndx;
7674
7675           switch (rp->r_offset / eh_addr_size % 3)
7676             {
7677             case 0:
7678               aux->table[i].start.section = sym->st_shndx;
7679               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
7680               break;
7681             case 1:
7682               aux->table[i].end.section   = sym->st_shndx;
7683               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
7684               break;
7685             case 2:
7686               aux->table[i].info.section  = sym->st_shndx;
7687               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
7688               break;
7689             default:
7690               break;
7691             }
7692         }
7693
7694       free (rela);
7695     }
7696
7697   return TRUE;
7698 }
7699
7700 static bfd_boolean
7701 ia64_process_unwind (Filedata * filedata)
7702 {
7703   Elf_Internal_Shdr * sec;
7704   Elf_Internal_Shdr * unwsec = NULL;
7705   Elf_Internal_Shdr * strsec;
7706   unsigned long i, unwcount = 0, unwstart = 0;
7707   struct ia64_unw_aux_info aux;
7708   bfd_boolean res = TRUE;
7709
7710   memset (& aux, 0, sizeof (aux));
7711
7712   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7713     {
7714       if (sec->sh_type == SHT_SYMTAB
7715           && sec->sh_link < filedata->file_header.e_shnum)
7716         {
7717           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
7718
7719           strsec = filedata->section_headers + sec->sh_link;
7720           if (aux.strtab != NULL)
7721             {
7722               error (_("Multiple auxillary string tables encountered\n"));
7723               free (aux.strtab);
7724               res = FALSE;
7725             }
7726           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7727                                           1, strsec->sh_size,
7728                                           _("string table"));
7729           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7730         }
7731       else if (sec->sh_type == SHT_IA_64_UNWIND)
7732         unwcount++;
7733     }
7734
7735   if (!unwcount)
7736     printf (_("\nThere are no unwind sections in this file.\n"));
7737
7738   while (unwcount-- > 0)
7739     {
7740       char * suffix;
7741       size_t len, len2;
7742
7743       for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7744            i < filedata->file_header.e_shnum; ++i, ++sec)
7745         if (sec->sh_type == SHT_IA_64_UNWIND)
7746           {
7747             unwsec = sec;
7748             break;
7749           }
7750       /* We have already counted the number of SHT_IA64_UNWIND
7751          sections so the loop above should never fail.  */
7752       assert (unwsec != NULL);
7753
7754       unwstart = i + 1;
7755       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7756
7757       if ((unwsec->sh_flags & SHF_GROUP) != 0)
7758         {
7759           /* We need to find which section group it is in.  */
7760           struct group_list * g;
7761
7762           if (section_headers_groups == NULL
7763               || section_headers_groups [i] == NULL)
7764             i = filedata->file_header.e_shnum;
7765           else
7766             {
7767               g = section_headers_groups [i]->root;
7768
7769               for (; g != NULL; g = g->next)
7770                 {
7771                   sec = filedata->section_headers + g->section_index;
7772
7773                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7774                     break;
7775                 }
7776
7777               if (g == NULL)
7778                 i = filedata->file_header.e_shnum;
7779             }
7780         }
7781       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7782         {
7783           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
7784           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7785           suffix = SECTION_NAME (unwsec) + len;
7786           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7787                ++i, ++sec)
7788             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7789                 && streq (SECTION_NAME (sec) + len2, suffix))
7790               break;
7791         }
7792       else
7793         {
7794           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7795              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
7796           len = sizeof (ELF_STRING_ia64_unwind) - 1;
7797           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7798           suffix = "";
7799           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7800             suffix = SECTION_NAME (unwsec) + len;
7801           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7802                ++i, ++sec)
7803             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7804                 && streq (SECTION_NAME (sec) + len2, suffix))
7805               break;
7806         }
7807
7808       if (i == filedata->file_header.e_shnum)
7809         {
7810           printf (_("\nCould not find unwind info section for "));
7811
7812           if (filedata->string_table == NULL)
7813             printf ("%d", unwsec->sh_name);
7814           else
7815             printf ("'%s'", printable_section_name (filedata, unwsec));
7816         }
7817       else
7818         {
7819           aux.info_addr = sec->sh_addr;
7820           aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
7821                                                  sec->sh_size,
7822                                                  _("unwind info"));
7823           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7824
7825           printf (_("\nUnwind section "));
7826
7827           if (filedata->string_table == NULL)
7828             printf ("%d", unwsec->sh_name);
7829           else
7830             printf ("'%s'", printable_section_name (filedata, unwsec));
7831
7832           printf (_(" at offset 0x%lx contains %lu entries:\n"),
7833                   (unsigned long) unwsec->sh_offset,
7834                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7835
7836           if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
7837               && aux.table_len > 0)
7838             dump_ia64_unwind (filedata, & aux);
7839
7840           if (aux.table)
7841             free ((char *) aux.table);
7842           if (aux.info)
7843             free ((char *) aux.info);
7844           aux.table = NULL;
7845           aux.info = NULL;
7846         }
7847     }
7848
7849   if (aux.symtab)
7850     free (aux.symtab);
7851   if (aux.strtab)
7852     free ((char *) aux.strtab);
7853
7854   return res;
7855 }
7856
7857 struct hppa_unw_table_entry
7858 {
7859   struct absaddr start;
7860   struct absaddr end;
7861   unsigned int Cannot_unwind:1;                 /* 0 */
7862   unsigned int Millicode:1;                     /* 1 */
7863   unsigned int Millicode_save_sr0:1;            /* 2 */
7864   unsigned int Region_description:2;            /* 3..4 */
7865   unsigned int reserved1:1;                     /* 5 */
7866   unsigned int Entry_SR:1;                      /* 6 */
7867   unsigned int Entry_FR:4;     /* Number saved     7..10 */
7868   unsigned int Entry_GR:5;     /* Number saved     11..15 */
7869   unsigned int Args_stored:1;                   /* 16 */
7870   unsigned int Variable_Frame:1;                /* 17 */
7871   unsigned int Separate_Package_Body:1;         /* 18 */
7872   unsigned int Frame_Extension_Millicode:1;     /* 19 */
7873   unsigned int Stack_Overflow_Check:1;          /* 20 */
7874   unsigned int Two_Instruction_SP_Increment:1;  /* 21 */
7875   unsigned int Ada_Region:1;                    /* 22 */
7876   unsigned int cxx_info:1;                      /* 23 */
7877   unsigned int cxx_try_catch:1;                 /* 24 */
7878   unsigned int sched_entry_seq:1;               /* 25 */
7879   unsigned int reserved2:1;                     /* 26 */
7880   unsigned int Save_SP:1;                       /* 27 */
7881   unsigned int Save_RP:1;                       /* 28 */
7882   unsigned int Save_MRP_in_frame:1;             /* 29 */
7883   unsigned int extn_ptr_defined:1;              /* 30 */
7884   unsigned int Cleanup_defined:1;               /* 31 */
7885
7886   unsigned int MPE_XL_interrupt_marker:1;       /* 0 */
7887   unsigned int HP_UX_interrupt_marker:1;        /* 1 */
7888   unsigned int Large_frame:1;                   /* 2 */
7889   unsigned int Pseudo_SP_Set:1;                 /* 3 */
7890   unsigned int reserved4:1;                     /* 4 */
7891   unsigned int Total_frame_size:27;             /* 5..31 */
7892 };
7893
7894 struct hppa_unw_aux_info
7895 {
7896   struct hppa_unw_table_entry *  table;         /* Unwind table.  */
7897   unsigned long                  table_len;     /* Length of unwind table.  */
7898   bfd_vma                        seg_base;      /* Starting address of segment.  */
7899   Elf_Internal_Sym *             symtab;        /* The symbol table.  */
7900   unsigned long                  nsyms;         /* Number of symbols.  */
7901   Elf_Internal_Sym *             funtab;        /* Sorted table of STT_FUNC symbols.  */
7902   unsigned long                  nfuns;         /* Number of entries in funtab.  */
7903   char *                         strtab;        /* The string table.  */
7904   unsigned long                  strtab_size;   /* Size of string table.  */
7905 };
7906
7907 static bfd_boolean
7908 dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
7909 {
7910   struct hppa_unw_table_entry * tp;
7911   unsigned long j, nfuns;
7912   bfd_boolean res = TRUE;
7913
7914   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7915   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7916     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7917       aux->funtab[nfuns++] = aux->symtab[j];
7918   aux->nfuns = nfuns;
7919   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7920
7921   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7922     {
7923       bfd_vma offset;
7924       const char * procname;
7925
7926       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7927                                aux->strtab_size, tp->start, &procname,
7928                                &offset);
7929
7930       fputs ("\n<", stdout);
7931
7932       if (procname)
7933         {
7934           fputs (procname, stdout);
7935
7936           if (offset)
7937             printf ("+%lx", (unsigned long) offset);
7938         }
7939
7940       fputs (">: [", stdout);
7941       print_vma (tp->start.offset, PREFIX_HEX);
7942       fputc ('-', stdout);
7943       print_vma (tp->end.offset, PREFIX_HEX);
7944       printf ("]\n\t");
7945
7946 #define PF(_m) if (tp->_m) printf (#_m " ");
7947 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7948       PF(Cannot_unwind);
7949       PF(Millicode);
7950       PF(Millicode_save_sr0);
7951       /* PV(Region_description);  */
7952       PF(Entry_SR);
7953       PV(Entry_FR);
7954       PV(Entry_GR);
7955       PF(Args_stored);
7956       PF(Variable_Frame);
7957       PF(Separate_Package_Body);
7958       PF(Frame_Extension_Millicode);
7959       PF(Stack_Overflow_Check);
7960       PF(Two_Instruction_SP_Increment);
7961       PF(Ada_Region);
7962       PF(cxx_info);
7963       PF(cxx_try_catch);
7964       PF(sched_entry_seq);
7965       PF(Save_SP);
7966       PF(Save_RP);
7967       PF(Save_MRP_in_frame);
7968       PF(extn_ptr_defined);
7969       PF(Cleanup_defined);
7970       PF(MPE_XL_interrupt_marker);
7971       PF(HP_UX_interrupt_marker);
7972       PF(Large_frame);
7973       PF(Pseudo_SP_Set);
7974       PV(Total_frame_size);
7975 #undef PF
7976 #undef PV
7977     }
7978
7979   printf ("\n");
7980
7981   free (aux->funtab);
7982
7983   return res;
7984 }
7985
7986 static bfd_boolean
7987 slurp_hppa_unwind_table (Filedata *                  filedata,
7988                          struct hppa_unw_aux_info *  aux,
7989                          Elf_Internal_Shdr *         sec)
7990 {
7991   unsigned long size, unw_ent_size, nentries, nrelas, i;
7992   Elf_Internal_Phdr * seg;
7993   struct hppa_unw_table_entry * tep;
7994   Elf_Internal_Shdr * relsec;
7995   Elf_Internal_Rela * rela;
7996   Elf_Internal_Rela * rp;
7997   unsigned char * table;
7998   unsigned char * tp;
7999   Elf_Internal_Sym * sym;
8000   const char * relname;
8001
8002   /* First, find the starting address of the segment that includes
8003      this section.  */
8004   if (filedata->file_header.e_phnum)
8005     {
8006       if (! get_program_headers (filedata))
8007         return FALSE;
8008
8009       for (seg = filedata->program_headers;
8010            seg < filedata->program_headers + filedata->file_header.e_phnum;
8011            ++seg)
8012         {
8013           if (seg->p_type != PT_LOAD)
8014             continue;
8015
8016           if (sec->sh_addr >= seg->p_vaddr
8017               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
8018             {
8019               aux->seg_base = seg->p_vaddr;
8020               break;
8021             }
8022         }
8023     }
8024
8025   /* Second, build the unwind table from the contents of the unwind
8026      section.  */
8027   size = sec->sh_size;
8028   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
8029                                       _("unwind table"));
8030   if (!table)
8031     return FALSE;
8032
8033   unw_ent_size = 16;
8034   nentries = size / unw_ent_size;
8035   size = unw_ent_size * nentries;
8036
8037   tep = aux->table = (struct hppa_unw_table_entry *)
8038       xcmalloc (nentries, sizeof (aux->table[0]));
8039
8040   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
8041     {
8042       unsigned int tmp1, tmp2;
8043
8044       tep->start.section = SHN_UNDEF;
8045       tep->end.section   = SHN_UNDEF;
8046
8047       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
8048       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
8049       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
8050       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
8051
8052       tep->start.offset += aux->seg_base;
8053       tep->end.offset   += aux->seg_base;
8054
8055       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
8056       tep->Millicode = (tmp1 >> 30) & 0x1;
8057       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
8058       tep->Region_description = (tmp1 >> 27) & 0x3;
8059       tep->reserved1 = (tmp1 >> 26) & 0x1;
8060       tep->Entry_SR = (tmp1 >> 25) & 0x1;
8061       tep->Entry_FR = (tmp1 >> 21) & 0xf;
8062       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
8063       tep->Args_stored = (tmp1 >> 15) & 0x1;
8064       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
8065       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
8066       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
8067       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
8068       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
8069       tep->Ada_Region = (tmp1 >> 9) & 0x1;
8070       tep->cxx_info = (tmp1 >> 8) & 0x1;
8071       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
8072       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
8073       tep->reserved2 = (tmp1 >> 5) & 0x1;
8074       tep->Save_SP = (tmp1 >> 4) & 0x1;
8075       tep->Save_RP = (tmp1 >> 3) & 0x1;
8076       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
8077       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
8078       tep->Cleanup_defined = tmp1 & 0x1;
8079
8080       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
8081       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
8082       tep->Large_frame = (tmp2 >> 29) & 0x1;
8083       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
8084       tep->reserved4 = (tmp2 >> 27) & 0x1;
8085       tep->Total_frame_size = tmp2 & 0x7ffffff;
8086     }
8087   free (table);
8088
8089   /* Third, apply any relocations to the unwind table.  */
8090   for (relsec = filedata->section_headers;
8091        relsec < filedata->section_headers + filedata->file_header.e_shnum;
8092        ++relsec)
8093     {
8094       if (relsec->sh_type != SHT_RELA
8095           || relsec->sh_info >= filedata->file_header.e_shnum
8096           || filedata->section_headers + relsec->sh_info != sec)
8097         continue;
8098
8099       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
8100                               & rela, & nrelas))
8101         return FALSE;
8102
8103       for (rp = rela; rp < rela + nrelas; ++rp)
8104         {
8105           unsigned int sym_ndx;
8106           unsigned int r_type = get_reloc_type (filedata, rp->r_info);
8107           relname = elf_hppa_reloc_type (r_type);
8108
8109           if (relname == NULL)
8110             {
8111               warn (_("Skipping unknown relocation type: %u\n"), r_type);
8112               continue;
8113             }
8114
8115           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
8116           if (! const_strneq (relname, "R_PARISC_SEGREL"))
8117             {
8118               warn (_("Skipping unexpected relocation type: %s\n"), relname);
8119               continue;
8120             }
8121
8122           i = rp->r_offset / unw_ent_size;
8123           if (i >= aux->table_len)
8124             {
8125               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
8126               continue;
8127             }
8128
8129           sym_ndx = get_reloc_symindex (rp->r_info);
8130           if (sym_ndx >= aux->nsyms)
8131             {
8132               warn (_("Skipping reloc with invalid symbol index: %u\n"),
8133                     sym_ndx);
8134               continue;
8135             }
8136           sym = aux->symtab + sym_ndx;
8137
8138           switch ((rp->r_offset % unw_ent_size) / 4)
8139             {
8140             case 0:
8141               aux->table[i].start.section = sym->st_shndx;
8142               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
8143               break;
8144             case 1:
8145               aux->table[i].end.section   = sym->st_shndx;
8146               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
8147               break;
8148             default:
8149               break;
8150             }
8151         }
8152
8153       free (rela);
8154     }
8155
8156   aux->table_len = nentries;
8157
8158   return TRUE;
8159 }
8160
8161 static bfd_boolean
8162 hppa_process_unwind (Filedata * filedata)
8163 {
8164   struct hppa_unw_aux_info aux;
8165   Elf_Internal_Shdr * unwsec = NULL;
8166   Elf_Internal_Shdr * strsec;
8167   Elf_Internal_Shdr * sec;
8168   unsigned long i;
8169   bfd_boolean res = TRUE;
8170
8171   if (filedata->string_table == NULL)
8172     return FALSE;
8173
8174   memset (& aux, 0, sizeof (aux));
8175
8176   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8177     {
8178       if (sec->sh_type == SHT_SYMTAB
8179           && sec->sh_link < filedata->file_header.e_shnum)
8180         {
8181           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
8182
8183           strsec = filedata->section_headers + sec->sh_link;
8184           if (aux.strtab != NULL)
8185             {
8186               error (_("Multiple auxillary string tables encountered\n"));
8187               free (aux.strtab);
8188               res = FALSE;
8189             }
8190           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
8191                                           1, strsec->sh_size,
8192                                           _("string table"));
8193           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8194         }
8195       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8196         unwsec = sec;
8197     }
8198
8199   if (!unwsec)
8200     printf (_("\nThere are no unwind sections in this file.\n"));
8201
8202   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8203     {
8204       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8205         {
8206           unsigned long num_unwind = sec->sh_size / 16;
8207
8208           printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8209                             "contains %lu entry:\n",
8210                             "\nUnwind section '%s' at offset 0x%lx "
8211                             "contains %lu entries:\n",
8212                             num_unwind),
8213                   printable_section_name (filedata, sec),
8214                   (unsigned long) sec->sh_offset,
8215                   num_unwind);
8216
8217           if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8218             res = FALSE;
8219
8220           if (res && aux.table_len > 0)
8221             {
8222               if (! dump_hppa_unwind (filedata, &aux))
8223                 res = FALSE;
8224             }
8225
8226           if (aux.table)
8227             free ((char *) aux.table);
8228           aux.table = NULL;
8229         }
8230     }
8231
8232   if (aux.symtab)
8233     free (aux.symtab);
8234   if (aux.strtab)
8235     free ((char *) aux.strtab);
8236
8237   return res;
8238 }
8239
8240 struct arm_section
8241 {
8242   unsigned char *      data;            /* The unwind data.  */
8243   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
8244   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
8245   unsigned long        nrelas;          /* The number of relocations.  */
8246   unsigned int         rel_type;        /* REL or RELA ?  */
8247   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
8248 };
8249
8250 struct arm_unw_aux_info
8251 {
8252   Filedata *          filedata;         /* The file containing the unwind sections.  */
8253   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
8254   unsigned long       nsyms;            /* Number of symbols.  */
8255   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
8256   unsigned long       nfuns;            /* Number of these symbols.  */
8257   char *              strtab;           /* The file's string table.  */
8258   unsigned long       strtab_size;      /* Size of string table.  */
8259 };
8260
8261 static const char *
8262 arm_print_vma_and_name (Filedata *                 filedata,
8263                         struct arm_unw_aux_info *  aux,
8264                         bfd_vma                    fn,
8265                         struct absaddr             addr)
8266 {
8267   const char *procname;
8268   bfd_vma sym_offset;
8269
8270   if (addr.section == SHN_UNDEF)
8271     addr.offset = fn;
8272
8273   find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8274                            aux->strtab_size, addr, &procname,
8275                            &sym_offset);
8276
8277   print_vma (fn, PREFIX_HEX);
8278
8279   if (procname)
8280     {
8281       fputs (" <", stdout);
8282       fputs (procname, stdout);
8283
8284       if (sym_offset)
8285         printf ("+0x%lx", (unsigned long) sym_offset);
8286       fputc ('>', stdout);
8287     }
8288
8289   return procname;
8290 }
8291
8292 static void
8293 arm_free_section (struct arm_section *arm_sec)
8294 {
8295   if (arm_sec->data != NULL)
8296     free (arm_sec->data);
8297
8298   if (arm_sec->rela != NULL)
8299     free (arm_sec->rela);
8300 }
8301
8302 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8303       cached section and install SEC instead.
8304    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8305       and return its valued in * WORDP, relocating if necessary.
8306    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8307       relocation's offset in ADDR.
8308    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8309       into the string table of the symbol associated with the reloc.  If no
8310       reloc was applied store -1 there.
8311    5) Return TRUE upon success, FALSE otherwise.  */
8312
8313 static bfd_boolean
8314 get_unwind_section_word (Filedata *                 filedata,
8315                          struct arm_unw_aux_info *  aux,
8316                          struct arm_section *       arm_sec,
8317                          Elf_Internal_Shdr *        sec,
8318                          bfd_vma                    word_offset,
8319                          unsigned int *             wordp,
8320                          struct absaddr *           addr,
8321                          bfd_vma *                  sym_name)
8322 {
8323   Elf_Internal_Rela *rp;
8324   Elf_Internal_Sym *sym;
8325   const char * relname;
8326   unsigned int word;
8327   bfd_boolean wrapped;
8328
8329   if (sec == NULL || arm_sec == NULL)
8330     return FALSE;
8331
8332   addr->section = SHN_UNDEF;
8333   addr->offset = 0;
8334
8335   if (sym_name != NULL)
8336     *sym_name = (bfd_vma) -1;
8337
8338   /* If necessary, update the section cache.  */
8339   if (sec != arm_sec->sec)
8340     {
8341       Elf_Internal_Shdr *relsec;
8342
8343       arm_free_section (arm_sec);
8344
8345       arm_sec->sec = sec;
8346       arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8347                                 sec->sh_size, _("unwind data"));
8348       arm_sec->rela = NULL;
8349       arm_sec->nrelas = 0;
8350
8351       for (relsec = filedata->section_headers;
8352            relsec < filedata->section_headers + filedata->file_header.e_shnum;
8353            ++relsec)
8354         {
8355           if (relsec->sh_info >= filedata->file_header.e_shnum
8356               || filedata->section_headers + relsec->sh_info != sec
8357               /* PR 15745: Check the section type as well.  */
8358               || (relsec->sh_type != SHT_REL
8359                   && relsec->sh_type != SHT_RELA))
8360             continue;
8361
8362           arm_sec->rel_type = relsec->sh_type;
8363           if (relsec->sh_type == SHT_REL)
8364             {
8365               if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8366                                      relsec->sh_size,
8367                                      & arm_sec->rela, & arm_sec->nrelas))
8368                 return FALSE;
8369             }
8370           else /* relsec->sh_type == SHT_RELA */
8371             {
8372               if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8373                                       relsec->sh_size,
8374                                       & arm_sec->rela, & arm_sec->nrelas))
8375                 return FALSE;
8376             }
8377           break;
8378         }
8379
8380       arm_sec->next_rela = arm_sec->rela;
8381     }
8382
8383   /* If there is no unwind data we can do nothing.  */
8384   if (arm_sec->data == NULL)
8385     return FALSE;
8386
8387   /* If the offset is invalid then fail.  */
8388   if (/* PR 21343 *//* PR 18879 */
8389       sec->sh_size < 4
8390       || word_offset > (sec->sh_size - 4)
8391       || ((bfd_signed_vma) word_offset) < 0)
8392     return FALSE;
8393
8394   /* Get the word at the required offset.  */
8395   word = byte_get (arm_sec->data + word_offset, 4);
8396
8397   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
8398   if (arm_sec->rela == NULL)
8399     {
8400       * wordp = word;
8401       return TRUE;
8402     }
8403
8404   /* Look through the relocs to find the one that applies to the provided offset.  */
8405   wrapped = FALSE;
8406   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8407     {
8408       bfd_vma prelval, offset;
8409
8410       if (rp->r_offset > word_offset && !wrapped)
8411         {
8412           rp = arm_sec->rela;
8413           wrapped = TRUE;
8414         }
8415       if (rp->r_offset > word_offset)
8416         break;
8417
8418       if (rp->r_offset & 3)
8419         {
8420           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8421                 (unsigned long) rp->r_offset);
8422           continue;
8423         }
8424
8425       if (rp->r_offset < word_offset)
8426         continue;
8427
8428       /* PR 17531: file: 027-161405-0.004  */
8429       if (aux->symtab == NULL)
8430         continue;
8431
8432       if (arm_sec->rel_type == SHT_REL)
8433         {
8434           offset = word & 0x7fffffff;
8435           if (offset & 0x40000000)
8436             offset |= ~ (bfd_vma) 0x7fffffff;
8437         }
8438       else if (arm_sec->rel_type == SHT_RELA)
8439         offset = rp->r_addend;
8440       else
8441         {
8442           error (_("Unknown section relocation type %d encountered\n"),
8443                  arm_sec->rel_type);
8444           break;
8445         }
8446
8447       /* PR 17531 file: 027-1241568-0.004.  */
8448       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8449         {
8450           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8451                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8452           break;
8453         }
8454
8455       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8456       offset += sym->st_value;
8457       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8458
8459       /* Check that we are processing the expected reloc type.  */
8460       if (filedata->file_header.e_machine == EM_ARM)
8461         {
8462           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8463           if (relname == NULL)
8464             {
8465               warn (_("Skipping unknown ARM relocation type: %d\n"),
8466                     (int) ELF32_R_TYPE (rp->r_info));
8467               continue;
8468             }
8469
8470           if (streq (relname, "R_ARM_NONE"))
8471               continue;
8472
8473           if (! streq (relname, "R_ARM_PREL31"))
8474             {
8475               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8476               continue;
8477             }
8478         }
8479       else if (filedata->file_header.e_machine == EM_TI_C6000)
8480         {
8481           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8482           if (relname == NULL)
8483             {
8484               warn (_("Skipping unknown C6000 relocation type: %d\n"),
8485                     (int) ELF32_R_TYPE (rp->r_info));
8486               continue;
8487             }
8488
8489           if (streq (relname, "R_C6000_NONE"))
8490             continue;
8491
8492           if (! streq (relname, "R_C6000_PREL31"))
8493             {
8494               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8495               continue;
8496             }
8497
8498           prelval >>= 1;
8499         }
8500       else
8501         {
8502           /* This function currently only supports ARM and TI unwinders.  */
8503           warn (_("Only TI and ARM unwinders are currently supported\n"));
8504           break;
8505         }
8506
8507       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8508       addr->section = sym->st_shndx;
8509       addr->offset = offset;
8510
8511       if (sym_name)
8512         * sym_name = sym->st_name;
8513       break;
8514     }
8515
8516   *wordp = word;
8517   arm_sec->next_rela = rp;
8518
8519   return TRUE;
8520 }
8521
8522 static const char *tic6x_unwind_regnames[16] =
8523 {
8524   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8525   "A14", "A13", "A12", "A11", "A10",
8526   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8527 };
8528
8529 static void
8530 decode_tic6x_unwind_regmask (unsigned int mask)
8531 {
8532   int i;
8533
8534   for (i = 12; mask; mask >>= 1, i--)
8535     {
8536       if (mask & 1)
8537         {
8538           fputs (tic6x_unwind_regnames[i], stdout);
8539           if (mask > 1)
8540             fputs (", ", stdout);
8541         }
8542     }
8543 }
8544
8545 #define ADVANCE                                                 \
8546   if (remaining == 0 && more_words)                             \
8547     {                                                           \
8548       data_offset += 4;                                         \
8549       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec,     \
8550                                      data_offset, & word, & addr, NULL))        \
8551         return FALSE;                                           \
8552       remaining = 4;                                            \
8553       more_words--;                                             \
8554     }                                                           \
8555
8556 #define GET_OP(OP)                      \
8557   ADVANCE;                              \
8558   if (remaining)                        \
8559     {                                   \
8560       remaining--;                      \
8561       (OP) = word >> 24;                \
8562       word <<= 8;                       \
8563     }                                   \
8564   else                                  \
8565     {                                   \
8566       printf (_("[Truncated opcode]\n"));       \
8567       return FALSE;                     \
8568     }                                   \
8569   printf ("0x%02x ", OP)
8570
8571 static bfd_boolean
8572 decode_arm_unwind_bytecode (Filedata *                 filedata,
8573                             struct arm_unw_aux_info *  aux,
8574                             unsigned int               word,
8575                             unsigned int               remaining,
8576                             unsigned int               more_words,
8577                             bfd_vma                    data_offset,
8578                             Elf_Internal_Shdr *        data_sec,
8579                             struct arm_section *       data_arm_sec)
8580 {
8581   struct absaddr addr;
8582   bfd_boolean res = TRUE;
8583
8584   /* Decode the unwinding instructions.  */
8585   while (1)
8586     {
8587       unsigned int op, op2;
8588
8589       ADVANCE;
8590       if (remaining == 0)
8591         break;
8592       remaining--;
8593       op = word >> 24;
8594       word <<= 8;
8595
8596       printf ("  0x%02x ", op);
8597
8598       if ((op & 0xc0) == 0x00)
8599         {
8600           int offset = ((op & 0x3f) << 2) + 4;
8601
8602           printf ("     vsp = vsp + %d", offset);
8603         }
8604       else if ((op & 0xc0) == 0x40)
8605         {
8606           int offset = ((op & 0x3f) << 2) + 4;
8607
8608           printf ("     vsp = vsp - %d", offset);
8609         }
8610       else if ((op & 0xf0) == 0x80)
8611         {
8612           GET_OP (op2);
8613           if (op == 0x80 && op2 == 0)
8614             printf (_("Refuse to unwind"));
8615           else
8616             {
8617               unsigned int mask = ((op & 0x0f) << 8) | op2;
8618               bfd_boolean first = TRUE;
8619               int i;
8620
8621               printf ("pop {");
8622               for (i = 0; i < 12; i++)
8623                 if (mask & (1 << i))
8624                   {
8625                     if (first)
8626                       first = FALSE;
8627                     else
8628                       printf (", ");
8629                     printf ("r%d", 4 + i);
8630                   }
8631               printf ("}");
8632             }
8633         }
8634       else if ((op & 0xf0) == 0x90)
8635         {
8636           if (op == 0x9d || op == 0x9f)
8637             printf (_("     [Reserved]"));
8638           else
8639             printf ("     vsp = r%d", op & 0x0f);
8640         }
8641       else if ((op & 0xf0) == 0xa0)
8642         {
8643           int end = 4 + (op & 0x07);
8644           bfd_boolean first = TRUE;
8645           int i;
8646
8647           printf ("     pop {");
8648           for (i = 4; i <= end; i++)
8649             {
8650               if (first)
8651                 first = FALSE;
8652               else
8653                 printf (", ");
8654               printf ("r%d", i);
8655             }
8656           if (op & 0x08)
8657             {
8658               if (!first)
8659                 printf (", ");
8660               printf ("r14");
8661             }
8662           printf ("}");
8663         }
8664       else if (op == 0xb0)
8665         printf (_("     finish"));
8666       else if (op == 0xb1)
8667         {
8668           GET_OP (op2);
8669           if (op2 == 0 || (op2 & 0xf0) != 0)
8670             printf (_("[Spare]"));
8671           else
8672             {
8673               unsigned int mask = op2 & 0x0f;
8674               bfd_boolean first = TRUE;
8675               int i;
8676
8677               printf ("pop {");
8678               for (i = 0; i < 12; i++)
8679                 if (mask & (1 << i))
8680                   {
8681                     if (first)
8682                       first = FALSE;
8683                     else
8684                       printf (", ");
8685                     printf ("r%d", i);
8686                   }
8687               printf ("}");
8688             }
8689         }
8690       else if (op == 0xb2)
8691         {
8692           unsigned char buf[9];
8693           unsigned int i, len;
8694           unsigned long offset;
8695
8696           for (i = 0; i < sizeof (buf); i++)
8697             {
8698               GET_OP (buf[i]);
8699               if ((buf[i] & 0x80) == 0)
8700                 break;
8701             }
8702           if (i == sizeof (buf))
8703             {
8704               error (_("corrupt change to vsp"));
8705               res = FALSE;
8706             }
8707           else
8708             {
8709               offset = read_uleb128 (buf, &len, buf + i + 1);
8710               assert (len == i + 1);
8711               offset = offset * 4 + 0x204;
8712               printf ("vsp = vsp + %ld", offset);
8713             }
8714         }
8715       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8716         {
8717           unsigned int first, last;
8718
8719           GET_OP (op2);
8720           first = op2 >> 4;
8721           last = op2 & 0x0f;
8722           if (op == 0xc8)
8723             first = first + 16;
8724           printf ("pop {D%d", first);
8725           if (last)
8726             printf ("-D%d", first + last);
8727           printf ("}");
8728         }
8729       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8730         {
8731           unsigned int count = op & 0x07;
8732
8733           printf ("pop {D8");
8734           if (count)
8735             printf ("-D%d", 8 + count);
8736           printf ("}");
8737         }
8738       else if (op >= 0xc0 && op <= 0xc5)
8739         {
8740           unsigned int count = op & 0x07;
8741
8742           printf ("     pop {wR10");
8743           if (count)
8744             printf ("-wR%d", 10 + count);
8745           printf ("}");
8746         }
8747       else if (op == 0xc6)
8748         {
8749           unsigned int first, last;
8750
8751           GET_OP (op2);
8752           first = op2 >> 4;
8753           last = op2 & 0x0f;
8754           printf ("pop {wR%d", first);
8755           if (last)
8756             printf ("-wR%d", first + last);
8757           printf ("}");
8758         }
8759       else if (op == 0xc7)
8760         {
8761           GET_OP (op2);
8762           if (op2 == 0 || (op2 & 0xf0) != 0)
8763             printf (_("[Spare]"));
8764           else
8765             {
8766               unsigned int mask = op2 & 0x0f;
8767               bfd_boolean first = TRUE;
8768               int i;
8769
8770               printf ("pop {");
8771               for (i = 0; i < 4; i++)
8772                 if (mask & (1 << i))
8773                   {
8774                     if (first)
8775                       first = FALSE;
8776                     else
8777                       printf (", ");
8778                     printf ("wCGR%d", i);
8779                   }
8780               printf ("}");
8781             }
8782         }
8783       else
8784         {
8785           printf (_("     [unsupported opcode]"));
8786           res = FALSE;
8787         }
8788
8789       printf ("\n");
8790     }
8791
8792   return res;
8793 }
8794
8795 static bfd_boolean
8796 decode_tic6x_unwind_bytecode (Filedata *                 filedata,
8797                               struct arm_unw_aux_info *  aux,
8798                               unsigned int               word,
8799                               unsigned int               remaining,
8800                               unsigned int               more_words,
8801                               bfd_vma                    data_offset,
8802                               Elf_Internal_Shdr *        data_sec,
8803                               struct arm_section *       data_arm_sec)
8804 {
8805   struct absaddr addr;
8806
8807   /* Decode the unwinding instructions.  */
8808   while (1)
8809     {
8810       unsigned int op, op2;
8811
8812       ADVANCE;
8813       if (remaining == 0)
8814         break;
8815       remaining--;
8816       op = word >> 24;
8817       word <<= 8;
8818
8819       printf ("  0x%02x ", op);
8820
8821       if ((op & 0xc0) == 0x00)
8822         {
8823           int offset = ((op & 0x3f) << 3) + 8;
8824           printf ("     sp = sp + %d", offset);
8825         }
8826       else if ((op & 0xc0) == 0x80)
8827         {
8828           GET_OP (op2);
8829           if (op == 0x80 && op2 == 0)
8830             printf (_("Refuse to unwind"));
8831           else
8832             {
8833               unsigned int mask = ((op & 0x1f) << 8) | op2;
8834               if (op & 0x20)
8835                 printf ("pop compact {");
8836               else
8837                 printf ("pop {");
8838
8839               decode_tic6x_unwind_regmask (mask);
8840               printf("}");
8841             }
8842         }
8843       else if ((op & 0xf0) == 0xc0)
8844         {
8845           unsigned int reg;
8846           unsigned int nregs;
8847           unsigned int i;
8848           const char *name;
8849           struct
8850           {
8851             unsigned int offset;
8852             unsigned int reg;
8853           } regpos[16];
8854
8855           /* Scan entire instruction first so that GET_OP output is not
8856              interleaved with disassembly.  */
8857           nregs = 0;
8858           for (i = 0; nregs < (op & 0xf); i++)
8859             {
8860               GET_OP (op2);
8861               reg = op2 >> 4;
8862               if (reg != 0xf)
8863                 {
8864                   regpos[nregs].offset = i * 2;
8865                   regpos[nregs].reg = reg;
8866                   nregs++;
8867                 }
8868
8869               reg = op2 & 0xf;
8870               if (reg != 0xf)
8871                 {
8872                   regpos[nregs].offset = i * 2 + 1;
8873                   regpos[nregs].reg = reg;
8874                   nregs++;
8875                 }
8876             }
8877
8878           printf (_("pop frame {"));
8879           if (nregs == 0)
8880             {
8881               printf (_("*corrupt* - no registers specified"));
8882             }
8883           else
8884             {
8885               reg = nregs - 1;
8886               for (i = i * 2; i > 0; i--)
8887                 {
8888                   if (regpos[reg].offset == i - 1)
8889                     {
8890                       name = tic6x_unwind_regnames[regpos[reg].reg];
8891                       if (reg > 0)
8892                         reg--;
8893                     }
8894                   else
8895                     name = _("[pad]");
8896
8897                   fputs (name, stdout);
8898                   if (i > 1)
8899                     printf (", ");
8900                 }
8901             }
8902
8903           printf ("}");
8904         }
8905       else if (op == 0xd0)
8906         printf ("     MOV FP, SP");
8907       else if (op == 0xd1)
8908         printf ("     __c6xabi_pop_rts");
8909       else if (op == 0xd2)
8910         {
8911           unsigned char buf[9];
8912           unsigned int i, len;
8913           unsigned long offset;
8914
8915           for (i = 0; i < sizeof (buf); i++)
8916             {
8917               GET_OP (buf[i]);
8918               if ((buf[i] & 0x80) == 0)
8919                 break;
8920             }
8921           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8922           if (i == sizeof (buf))
8923             {
8924               warn (_("Corrupt stack pointer adjustment detected\n"));
8925               return FALSE;
8926             }
8927
8928           offset = read_uleb128 (buf, &len, buf + i + 1);
8929           assert (len == i + 1);
8930           offset = offset * 8 + 0x408;
8931           printf (_("sp = sp + %ld"), offset);
8932         }
8933       else if ((op & 0xf0) == 0xe0)
8934         {
8935           if ((op & 0x0f) == 7)
8936             printf ("     RETURN");
8937           else
8938             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8939         }
8940       else
8941         {
8942           printf (_("     [unsupported opcode]"));
8943         }
8944       putchar ('\n');
8945     }
8946
8947   return TRUE;
8948 }
8949
8950 static bfd_vma
8951 arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
8952 {
8953   bfd_vma offset;
8954
8955   offset = word & 0x7fffffff;
8956   if (offset & 0x40000000)
8957     offset |= ~ (bfd_vma) 0x7fffffff;
8958
8959   if (filedata->file_header.e_machine == EM_TI_C6000)
8960     offset <<= 1;
8961
8962   return offset + where;
8963 }
8964
8965 static bfd_boolean
8966 decode_arm_unwind (Filedata *                 filedata,
8967                    struct arm_unw_aux_info *  aux,
8968                    unsigned int               word,
8969                    unsigned int               remaining,
8970                    bfd_vma                    data_offset,
8971                    Elf_Internal_Shdr *        data_sec,
8972                    struct arm_section *       data_arm_sec)
8973 {
8974   int per_index;
8975   unsigned int more_words = 0;
8976   struct absaddr addr;
8977   bfd_vma sym_name = (bfd_vma) -1;
8978   bfd_boolean res = TRUE;
8979
8980   if (remaining == 0)
8981     {
8982       /* Fetch the first word.
8983          Note - when decoding an object file the address extracted
8984          here will always be 0.  So we also pass in the sym_name
8985          parameter so that we can find the symbol associated with
8986          the personality routine.  */
8987       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
8988                                      & word, & addr, & sym_name))
8989         return FALSE;
8990
8991       remaining = 4;
8992     }
8993
8994   if ((word & 0x80000000) == 0)
8995     {
8996       /* Expand prel31 for personality routine.  */
8997       bfd_vma fn;
8998       const char *procname;
8999
9000       fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
9001       printf (_("  Personality routine: "));
9002       if (fn == 0
9003           && addr.section == SHN_UNDEF && addr.offset == 0
9004           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
9005         {
9006           procname = aux->strtab + sym_name;
9007           print_vma (fn, PREFIX_HEX);
9008           if (procname)
9009             {
9010               fputs (" <", stdout);
9011               fputs (procname, stdout);
9012               fputc ('>', stdout);
9013             }
9014         }
9015       else
9016         procname = arm_print_vma_and_name (filedata, aux, fn, addr);
9017       fputc ('\n', stdout);
9018
9019       /* The GCC personality routines use the standard compact
9020          encoding, starting with one byte giving the number of
9021          words.  */
9022       if (procname != NULL
9023           && (const_strneq (procname, "__gcc_personality_v0")
9024               || const_strneq (procname, "__gxx_personality_v0")
9025               || const_strneq (procname, "__gcj_personality_v0")
9026               || const_strneq (procname, "__gnu_objc_personality_v0")))
9027         {
9028           remaining = 0;
9029           more_words = 1;
9030           ADVANCE;
9031           if (!remaining)
9032             {
9033               printf (_("  [Truncated data]\n"));
9034               return FALSE;
9035             }
9036           more_words = word >> 24;
9037           word <<= 8;
9038           remaining--;
9039           per_index = -1;
9040         }
9041       else
9042         return TRUE;
9043     }
9044   else
9045     {
9046       /* ARM EHABI Section 6.3:
9047
9048          An exception-handling table entry for the compact model looks like:
9049
9050            31 30-28 27-24 23-0
9051            -- ----- ----- ----
9052             1   0   index Data for personalityRoutine[index]    */
9053
9054       if (filedata->file_header.e_machine == EM_ARM
9055           && (word & 0x70000000))
9056         {
9057           warn (_("Corrupt ARM compact model table entry: %x \n"), word);
9058           res = FALSE;
9059         }
9060
9061       per_index = (word >> 24) & 0x7f;
9062       printf (_("  Compact model index: %d\n"), per_index);
9063       if (per_index == 0)
9064         {
9065           more_words = 0;
9066           word <<= 8;
9067           remaining--;
9068         }
9069       else if (per_index < 3)
9070         {
9071           more_words = (word >> 16) & 0xff;
9072           word <<= 16;
9073           remaining -= 2;
9074         }
9075     }
9076
9077   switch (filedata->file_header.e_machine)
9078     {
9079     case EM_ARM:
9080       if (per_index < 3)
9081         {
9082           if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
9083                                             data_offset, data_sec, data_arm_sec))
9084             res = FALSE;
9085         }
9086       else
9087         {
9088           warn (_("Unknown ARM compact model index encountered\n"));
9089           printf (_("  [reserved]\n"));
9090           res = FALSE;
9091         }
9092       break;
9093
9094     case EM_TI_C6000:
9095       if (per_index < 3)
9096         {
9097           if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
9098                                               data_offset, data_sec, data_arm_sec))
9099             res = FALSE;
9100         }
9101       else if (per_index < 5)
9102         {
9103           if (((word >> 17) & 0x7f) == 0x7f)
9104             printf (_("  Restore stack from frame pointer\n"));
9105           else
9106             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
9107           printf (_("  Registers restored: "));
9108           if (per_index == 4)
9109             printf (" (compact) ");
9110           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
9111           putchar ('\n');
9112           printf (_("  Return register: %s\n"),
9113                   tic6x_unwind_regnames[word & 0xf]);
9114         }
9115       else
9116         printf (_("  [reserved (%d)]\n"), per_index);
9117       break;
9118
9119     default:
9120       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9121              filedata->file_header.e_machine);
9122       res = FALSE;
9123     }
9124
9125   /* Decode the descriptors.  Not implemented.  */
9126
9127   return res;
9128 }
9129
9130 static bfd_boolean
9131 dump_arm_unwind (Filedata *                 filedata,
9132                  struct arm_unw_aux_info *  aux,
9133                  Elf_Internal_Shdr *        exidx_sec)
9134 {
9135   struct arm_section exidx_arm_sec, extab_arm_sec;
9136   unsigned int i, exidx_len;
9137   unsigned long j, nfuns;
9138   bfd_boolean res = TRUE;
9139
9140   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
9141   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
9142   exidx_len = exidx_sec->sh_size / 8;
9143
9144   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
9145   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
9146     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
9147       aux->funtab[nfuns++] = aux->symtab[j];
9148   aux->nfuns = nfuns;
9149   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
9150
9151   for (i = 0; i < exidx_len; i++)
9152     {
9153       unsigned int exidx_fn, exidx_entry;
9154       struct absaddr fn_addr, entry_addr;
9155       bfd_vma fn;
9156
9157       fputc ('\n', stdout);
9158
9159       if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9160                                      8 * i, & exidx_fn, & fn_addr, NULL)
9161           || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9162                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
9163         {
9164           free (aux->funtab);
9165           arm_free_section (& exidx_arm_sec);
9166           arm_free_section (& extab_arm_sec);
9167           return FALSE;
9168         }
9169
9170       /* ARM EHABI, Section 5:
9171          An index table entry consists of 2 words.
9172          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
9173       if (exidx_fn & 0x80000000)
9174         {
9175           warn (_("corrupt index table entry: %x\n"), exidx_fn);
9176           res = FALSE;
9177         }
9178
9179       fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9180
9181       arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9182       fputs (": ", stdout);
9183
9184       if (exidx_entry == 1)
9185         {
9186           print_vma (exidx_entry, PREFIX_HEX);
9187           fputs (" [cantunwind]\n", stdout);
9188         }
9189       else if (exidx_entry & 0x80000000)
9190         {
9191           print_vma (exidx_entry, PREFIX_HEX);
9192           fputc ('\n', stdout);
9193           decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9194         }
9195       else
9196         {
9197           bfd_vma table, table_offset = 0;
9198           Elf_Internal_Shdr *table_sec;
9199
9200           fputs ("@", stdout);
9201           table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9202           print_vma (table, PREFIX_HEX);
9203           printf ("\n");
9204
9205           /* Locate the matching .ARM.extab.  */
9206           if (entry_addr.section != SHN_UNDEF
9207               && entry_addr.section < filedata->file_header.e_shnum)
9208             {
9209               table_sec = filedata->section_headers + entry_addr.section;
9210               table_offset = entry_addr.offset;
9211               /* PR 18879 */
9212               if (table_offset > table_sec->sh_size
9213                   || ((bfd_signed_vma) table_offset) < 0)
9214                 {
9215                   warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9216                         (unsigned long) table_offset,
9217                         printable_section_name (filedata, table_sec));
9218                   res = FALSE;
9219                   continue;
9220                 }
9221             }
9222           else
9223             {
9224               table_sec = find_section_by_address (filedata, table);
9225               if (table_sec != NULL)
9226                 table_offset = table - table_sec->sh_addr;
9227             }
9228
9229           if (table_sec == NULL)
9230             {
9231               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9232                     (unsigned long) table);
9233               res = FALSE;
9234               continue;
9235             }
9236
9237           if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9238                                    &extab_arm_sec))
9239             res = FALSE;
9240         }
9241     }
9242
9243   printf ("\n");
9244
9245   free (aux->funtab);
9246   arm_free_section (&exidx_arm_sec);
9247   arm_free_section (&extab_arm_sec);
9248
9249   return res;
9250 }
9251
9252 /* Used for both ARM and C6X unwinding tables.  */
9253
9254 static bfd_boolean
9255 arm_process_unwind (Filedata * filedata)
9256 {
9257   struct arm_unw_aux_info aux;
9258   Elf_Internal_Shdr *unwsec = NULL;
9259   Elf_Internal_Shdr *strsec;
9260   Elf_Internal_Shdr *sec;
9261   unsigned long i;
9262   unsigned int sec_type;
9263   bfd_boolean res = TRUE;
9264
9265   switch (filedata->file_header.e_machine)
9266     {
9267     case EM_ARM:
9268       sec_type = SHT_ARM_EXIDX;
9269       break;
9270
9271     case EM_TI_C6000:
9272       sec_type = SHT_C6000_UNWIND;
9273       break;
9274
9275     default:
9276       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9277              filedata->file_header.e_machine);
9278       return FALSE;
9279     }
9280
9281   if (filedata->string_table == NULL)
9282     return FALSE;
9283
9284   memset (& aux, 0, sizeof (aux));
9285   aux.filedata = filedata;
9286
9287   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9288     {
9289       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < filedata->file_header.e_shnum)
9290         {
9291           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
9292
9293           strsec = filedata->section_headers + sec->sh_link;
9294
9295           /* PR binutils/17531 file: 011-12666-0.004.  */
9296           if (aux.strtab != NULL)
9297             {
9298               error (_("Multiple string tables found in file.\n"));
9299               free (aux.strtab);
9300               res = FALSE;
9301             }
9302           aux.strtab = get_data (NULL, filedata, strsec->sh_offset,
9303                                  1, strsec->sh_size, _("string table"));
9304           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9305         }
9306       else if (sec->sh_type == sec_type)
9307         unwsec = sec;
9308     }
9309
9310   if (unwsec == NULL)
9311     printf (_("\nThere are no unwind sections in this file.\n"));
9312   else
9313     for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9314       {
9315         if (sec->sh_type == sec_type)
9316           {
9317             unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9318             printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9319                               "contains %lu entry:\n",
9320                               "\nUnwind section '%s' at offset 0x%lx "
9321                               "contains %lu entries:\n",
9322                               num_unwind),
9323                     printable_section_name (filedata, sec),
9324                     (unsigned long) sec->sh_offset,
9325                     num_unwind);
9326
9327             if (! dump_arm_unwind (filedata, &aux, sec))
9328               res = FALSE;
9329           }
9330       }
9331
9332   if (aux.symtab)
9333     free (aux.symtab);
9334   if (aux.strtab)
9335     free ((char *) aux.strtab);
9336
9337   return res;
9338 }
9339
9340 static bfd_boolean
9341 process_unwind (Filedata * filedata)
9342 {
9343   struct unwind_handler
9344   {
9345     unsigned int machtype;
9346     bfd_boolean (* handler)(Filedata *);
9347   } handlers[] =
9348   {
9349     { EM_ARM, arm_process_unwind },
9350     { EM_IA_64, ia64_process_unwind },
9351     { EM_PARISC, hppa_process_unwind },
9352     { EM_TI_C6000, arm_process_unwind },
9353     { 0, NULL }
9354   };
9355   int i;
9356
9357   if (!do_unwind)
9358     return TRUE;
9359
9360   for (i = 0; handlers[i].handler != NULL; i++)
9361     if (filedata->file_header.e_machine == handlers[i].machtype)
9362       return handlers[i].handler (filedata);
9363
9364   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9365           get_machine_name (filedata->file_header.e_machine));
9366   return TRUE;
9367 }
9368
9369 static void
9370 dynamic_section_aarch64_val (Elf_Internal_Dyn * entry)
9371 {
9372   switch (entry->d_tag)
9373     {
9374     case DT_AARCH64_BTI_PLT:
9375     case DT_AARCH64_PAC_PLT:
9376       break;
9377     default:
9378       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9379       break;
9380     }
9381   putchar ('\n');
9382 }
9383
9384 static void
9385 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9386 {
9387   switch (entry->d_tag)
9388     {
9389     case DT_MIPS_FLAGS:
9390       if (entry->d_un.d_val == 0)
9391         printf (_("NONE"));
9392       else
9393         {
9394           static const char * opts[] =
9395           {
9396             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9397             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9398             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9399             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9400             "RLD_ORDER_SAFE"
9401           };
9402           unsigned int cnt;
9403           bfd_boolean first = TRUE;
9404
9405           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9406             if (entry->d_un.d_val & (1 << cnt))
9407               {
9408                 printf ("%s%s", first ? "" : " ", opts[cnt]);
9409                 first = FALSE;
9410               }
9411         }
9412       break;
9413
9414     case DT_MIPS_IVERSION:
9415       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9416         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9417       else
9418         {
9419           char buf[40];
9420           sprintf_vma (buf, entry->d_un.d_ptr);
9421           /* Note: coded this way so that there is a single string for translation.  */
9422           printf (_("<corrupt: %s>"), buf);
9423         }
9424       break;
9425
9426     case DT_MIPS_TIME_STAMP:
9427       {
9428         char timebuf[128];
9429         struct tm * tmp;
9430         time_t atime = entry->d_un.d_val;
9431
9432         tmp = gmtime (&atime);
9433         /* PR 17531: file: 6accc532.  */
9434         if (tmp == NULL)
9435           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9436         else
9437           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9438                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9439                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9440         printf (_("Time Stamp: %s"), timebuf);
9441       }
9442       break;
9443
9444     case DT_MIPS_RLD_VERSION:
9445     case DT_MIPS_LOCAL_GOTNO:
9446     case DT_MIPS_CONFLICTNO:
9447     case DT_MIPS_LIBLISTNO:
9448     case DT_MIPS_SYMTABNO:
9449     case DT_MIPS_UNREFEXTNO:
9450     case DT_MIPS_HIPAGENO:
9451     case DT_MIPS_DELTA_CLASS_NO:
9452     case DT_MIPS_DELTA_INSTANCE_NO:
9453     case DT_MIPS_DELTA_RELOC_NO:
9454     case DT_MIPS_DELTA_SYM_NO:
9455     case DT_MIPS_DELTA_CLASSSYM_NO:
9456     case DT_MIPS_COMPACT_SIZE:
9457       print_vma (entry->d_un.d_val, DEC);
9458       break;
9459
9460     default:
9461       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9462     }
9463     putchar ('\n');
9464 }
9465
9466 static void
9467 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9468 {
9469   switch (entry->d_tag)
9470     {
9471     case DT_HP_DLD_FLAGS:
9472       {
9473         static struct
9474         {
9475           long int bit;
9476           const char * str;
9477         }
9478         flags[] =
9479         {
9480           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9481           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9482           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9483           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9484           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9485           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9486           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9487           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9488           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9489           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9490           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9491           { DT_HP_GST, "HP_GST" },
9492           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9493           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9494           { DT_HP_NODELETE, "HP_NODELETE" },
9495           { DT_HP_GROUP, "HP_GROUP" },
9496           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9497         };
9498         bfd_boolean first = TRUE;
9499         size_t cnt;
9500         bfd_vma val = entry->d_un.d_val;
9501
9502         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9503           if (val & flags[cnt].bit)
9504             {
9505               if (! first)
9506                 putchar (' ');
9507               fputs (flags[cnt].str, stdout);
9508               first = FALSE;
9509               val ^= flags[cnt].bit;
9510             }
9511
9512         if (val != 0 || first)
9513           {
9514             if (! first)
9515               putchar (' ');
9516             print_vma (val, HEX);
9517           }
9518       }
9519       break;
9520
9521     default:
9522       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9523       break;
9524     }
9525   putchar ('\n');
9526 }
9527
9528 #ifdef BFD64
9529
9530 /* VMS vs Unix time offset and factor.  */
9531
9532 #define VMS_EPOCH_OFFSET 35067168000000000LL
9533 #define VMS_GRANULARITY_FACTOR 10000000
9534
9535 /* Display a VMS time in a human readable format.  */
9536
9537 static void
9538 print_vms_time (bfd_int64_t vmstime)
9539 {
9540   struct tm *tm;
9541   time_t unxtime;
9542
9543   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9544   tm = gmtime (&unxtime);
9545   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9546           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9547           tm->tm_hour, tm->tm_min, tm->tm_sec);
9548 }
9549 #endif /* BFD64 */
9550
9551 static void
9552 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9553 {
9554   switch (entry->d_tag)
9555     {
9556     case DT_IA_64_PLT_RESERVE:
9557       /* First 3 slots reserved.  */
9558       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9559       printf (" -- ");
9560       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9561       break;
9562
9563     case DT_IA_64_VMS_LINKTIME:
9564 #ifdef BFD64
9565       print_vms_time (entry->d_un.d_val);
9566 #endif
9567       break;
9568
9569     case DT_IA_64_VMS_LNKFLAGS:
9570       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9571       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9572         printf (" CALL_DEBUG");
9573       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9574         printf (" NOP0BUFS");
9575       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9576         printf (" P0IMAGE");
9577       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9578         printf (" MKTHREADS");
9579       if (entry->d_un.d_val & VMS_LF_UPCALLS)
9580         printf (" UPCALLS");
9581       if (entry->d_un.d_val & VMS_LF_IMGSTA)
9582         printf (" IMGSTA");
9583       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9584         printf (" INITIALIZE");
9585       if (entry->d_un.d_val & VMS_LF_MAIN)
9586         printf (" MAIN");
9587       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9588         printf (" EXE_INIT");
9589       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9590         printf (" TBK_IN_IMG");
9591       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9592         printf (" DBG_IN_IMG");
9593       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9594         printf (" TBK_IN_DSF");
9595       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9596         printf (" DBG_IN_DSF");
9597       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9598         printf (" SIGNATURES");
9599       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9600         printf (" REL_SEG_OFF");
9601       break;
9602
9603     default:
9604       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9605       break;
9606     }
9607   putchar ('\n');
9608 }
9609
9610 static bfd_boolean
9611 get_32bit_dynamic_section (Filedata * filedata)
9612 {
9613   Elf32_External_Dyn * edyn;
9614   Elf32_External_Dyn * ext;
9615   Elf_Internal_Dyn * entry;
9616
9617   edyn = (Elf32_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9618                                           dynamic_size, _("dynamic section"));
9619   if (!edyn)
9620     return FALSE;
9621
9622   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9623      might not have the luxury of section headers.  Look for the DT_NULL
9624      terminator to determine the number of entries.  */
9625   for (ext = edyn, dynamic_nent = 0;
9626        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9627        ext++)
9628     {
9629       dynamic_nent++;
9630       if (BYTE_GET (ext->d_tag) == DT_NULL)
9631         break;
9632     }
9633
9634   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9635                                                   sizeof (* entry));
9636   if (dynamic_section == NULL)
9637     {
9638       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9639              (unsigned long) dynamic_nent);
9640       free (edyn);
9641       return FALSE;
9642     }
9643
9644   for (ext = edyn, entry = dynamic_section;
9645        entry < dynamic_section + dynamic_nent;
9646        ext++, entry++)
9647     {
9648       entry->d_tag      = BYTE_GET (ext->d_tag);
9649       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9650     }
9651
9652   free (edyn);
9653
9654   return TRUE;
9655 }
9656
9657 static bfd_boolean
9658 get_64bit_dynamic_section (Filedata * filedata)
9659 {
9660   Elf64_External_Dyn * edyn;
9661   Elf64_External_Dyn * ext;
9662   Elf_Internal_Dyn * entry;
9663
9664   /* Read in the data.  */
9665   edyn = (Elf64_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9666                                           dynamic_size, _("dynamic section"));
9667   if (!edyn)
9668     return FALSE;
9669
9670   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9671      might not have the luxury of section headers.  Look for the DT_NULL
9672      terminator to determine the number of entries.  */
9673   for (ext = edyn, dynamic_nent = 0;
9674        /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer.  */
9675        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9676        ext++)
9677     {
9678       dynamic_nent++;
9679       if (BYTE_GET (ext->d_tag) == DT_NULL)
9680         break;
9681     }
9682
9683   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9684                                                   sizeof (* entry));
9685   if (dynamic_section == NULL)
9686     {
9687       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9688              (unsigned long) dynamic_nent);
9689       free (edyn);
9690       return FALSE;
9691     }
9692
9693   /* Convert from external to internal formats.  */
9694   for (ext = edyn, entry = dynamic_section;
9695        entry < dynamic_section + dynamic_nent;
9696        ext++, entry++)
9697     {
9698       entry->d_tag      = BYTE_GET (ext->d_tag);
9699       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9700     }
9701
9702   free (edyn);
9703
9704   return TRUE;
9705 }
9706
9707 static void
9708 print_dynamic_flags (bfd_vma flags)
9709 {
9710   bfd_boolean first = TRUE;
9711
9712   while (flags)
9713     {
9714       bfd_vma flag;
9715
9716       flag = flags & - flags;
9717       flags &= ~ flag;
9718
9719       if (first)
9720         first = FALSE;
9721       else
9722         putc (' ', stdout);
9723
9724       switch (flag)
9725         {
9726         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
9727         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
9728         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
9729         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
9730         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
9731         default:                fputs (_("unknown"), stdout); break;
9732         }
9733     }
9734   puts ("");
9735 }
9736
9737 /* Parse and display the contents of the dynamic section.  */
9738
9739 static bfd_boolean
9740 process_dynamic_section (Filedata * filedata)
9741 {
9742   Elf_Internal_Dyn * entry;
9743
9744   if (dynamic_size == 0)
9745     {
9746       if (do_dynamic)
9747         printf (_("\nThere is no dynamic section in this file.\n"));
9748
9749       return TRUE;
9750     }
9751
9752   if (is_32bit_elf)
9753     {
9754       if (! get_32bit_dynamic_section (filedata))
9755         return FALSE;
9756     }
9757   else
9758     {
9759       if (! get_64bit_dynamic_section (filedata))
9760         return FALSE;
9761     }
9762
9763   /* Find the appropriate symbol table.  */
9764   if (dynamic_symbols == NULL)
9765     {
9766       for (entry = dynamic_section;
9767            entry < dynamic_section + dynamic_nent;
9768            ++entry)
9769         {
9770           Elf_Internal_Shdr section;
9771
9772           if (entry->d_tag != DT_SYMTAB)
9773             continue;
9774
9775           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9776
9777           /* Since we do not know how big the symbol table is,
9778              we default to reading in the entire file (!) and
9779              processing that.  This is overkill, I know, but it
9780              should work.  */
9781           section.sh_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9782           if ((bfd_size_type) section.sh_offset > filedata->file_size)
9783             {
9784               /* See PR 21379 for a reproducer.  */
9785               error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9786               return FALSE;
9787             }
9788
9789           if (archive_file_offset != 0)
9790             section.sh_size = archive_file_size - section.sh_offset;
9791           else
9792             section.sh_size = filedata->file_size - section.sh_offset;
9793
9794           if (is_32bit_elf)
9795             section.sh_entsize = sizeof (Elf32_External_Sym);
9796           else
9797             section.sh_entsize = sizeof (Elf64_External_Sym);
9798           section.sh_name = filedata->string_table_length;
9799
9800           if (dynamic_symbols != NULL)
9801             {
9802               error (_("Multiple dynamic symbol table sections found\n"));
9803               free (dynamic_symbols);
9804             }
9805           dynamic_symbols = GET_ELF_SYMBOLS (filedata, &section, & num_dynamic_syms);
9806           if (num_dynamic_syms < 1)
9807             {
9808               error (_("Unable to determine the number of symbols to load\n"));
9809               continue;
9810             }
9811         }
9812     }
9813
9814   /* Similarly find a string table.  */
9815   if (dynamic_strings == NULL)
9816     {
9817       for (entry = dynamic_section;
9818            entry < dynamic_section + dynamic_nent;
9819            ++entry)
9820         {
9821           unsigned long offset;
9822           long str_tab_len;
9823
9824           if (entry->d_tag != DT_STRTAB)
9825             continue;
9826
9827           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9828
9829           /* Since we do not know how big the string table is,
9830              we default to reading in the entire file (!) and
9831              processing that.  This is overkill, I know, but it
9832              should work.  */
9833
9834           offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9835
9836           if (archive_file_offset != 0)
9837             str_tab_len = archive_file_size - offset;
9838           else
9839             str_tab_len = filedata->file_size - offset;
9840
9841           if (str_tab_len < 1)
9842             {
9843               error
9844                 (_("Unable to determine the length of the dynamic string table\n"));
9845               continue;
9846             }
9847
9848           if (dynamic_strings != NULL)
9849             {
9850               error (_("Multiple dynamic string tables found\n"));
9851               free (dynamic_strings);
9852             }
9853
9854           dynamic_strings = (char *) get_data (NULL, filedata, offset, 1,
9855                                                str_tab_len,
9856                                                _("dynamic string table"));
9857           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9858         }
9859     }
9860
9861   /* And find the syminfo section if available.  */
9862   if (dynamic_syminfo == NULL)
9863     {
9864       unsigned long syminsz = 0;
9865
9866       for (entry = dynamic_section;
9867            entry < dynamic_section + dynamic_nent;
9868            ++entry)
9869         {
9870           if (entry->d_tag == DT_SYMINENT)
9871             {
9872               /* Note: these braces are necessary to avoid a syntax
9873                  error from the SunOS4 C compiler.  */
9874               /* PR binutils/17531: A corrupt file can trigger this test.
9875                  So do not use an assert, instead generate an error message.  */
9876               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9877                 error (_("Bad value (%d) for SYMINENT entry\n"),
9878                        (int) entry->d_un.d_val);
9879             }
9880           else if (entry->d_tag == DT_SYMINSZ)
9881             syminsz = entry->d_un.d_val;
9882           else if (entry->d_tag == DT_SYMINFO)
9883             dynamic_syminfo_offset = offset_from_vma (filedata, entry->d_un.d_val,
9884                                                       syminsz);
9885         }
9886
9887       if (dynamic_syminfo_offset != 0 && syminsz != 0)
9888         {
9889           Elf_External_Syminfo * extsyminfo;
9890           Elf_External_Syminfo * extsym;
9891           Elf_Internal_Syminfo * syminfo;
9892
9893           /* There is a syminfo section.  Read the data.  */
9894           extsyminfo = (Elf_External_Syminfo *)
9895               get_data (NULL, filedata, dynamic_syminfo_offset, 1, syminsz,
9896                         _("symbol information"));
9897           if (!extsyminfo)
9898             return FALSE;
9899
9900           if (dynamic_syminfo != NULL)
9901             {
9902               error (_("Multiple dynamic symbol information sections found\n"));
9903               free (dynamic_syminfo);
9904             }
9905           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9906           if (dynamic_syminfo == NULL)
9907             {
9908               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9909                      (unsigned long) syminsz);
9910               return FALSE;
9911             }
9912
9913           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9914           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9915                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9916                ++syminfo, ++extsym)
9917             {
9918               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9919               syminfo->si_flags = BYTE_GET (extsym->si_flags);
9920             }
9921
9922           free (extsyminfo);
9923         }
9924     }
9925
9926   if (do_dynamic && dynamic_addr)
9927     printf (ngettext ("\nDynamic section at offset 0x%lx "
9928                       "contains %lu entry:\n",
9929                       "\nDynamic section at offset 0x%lx "
9930                       "contains %lu entries:\n",
9931                       dynamic_nent),
9932             dynamic_addr, (unsigned long) dynamic_nent);
9933   if (do_dynamic)
9934     printf (_("  Tag        Type                         Name/Value\n"));
9935
9936   for (entry = dynamic_section;
9937        entry < dynamic_section + dynamic_nent;
9938        entry++)
9939     {
9940       if (do_dynamic)
9941         {
9942           const char * dtype;
9943
9944           putchar (' ');
9945           print_vma (entry->d_tag, FULL_HEX);
9946           dtype = get_dynamic_type (filedata, entry->d_tag);
9947           printf (" (%s)%*s", dtype,
9948                   ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9949         }
9950
9951       switch (entry->d_tag)
9952         {
9953         case DT_FLAGS:
9954           if (do_dynamic)
9955             print_dynamic_flags (entry->d_un.d_val);
9956           break;
9957
9958         case DT_AUXILIARY:
9959         case DT_FILTER:
9960         case DT_CONFIG:
9961         case DT_DEPAUDIT:
9962         case DT_AUDIT:
9963           if (do_dynamic)
9964             {
9965               switch (entry->d_tag)
9966                 {
9967                 case DT_AUXILIARY:
9968                   printf (_("Auxiliary library"));
9969                   break;
9970
9971                 case DT_FILTER:
9972                   printf (_("Filter library"));
9973                   break;
9974
9975                 case DT_CONFIG:
9976                   printf (_("Configuration file"));
9977                   break;
9978
9979                 case DT_DEPAUDIT:
9980                   printf (_("Dependency audit library"));
9981                   break;
9982
9983                 case DT_AUDIT:
9984                   printf (_("Audit library"));
9985                   break;
9986                 }
9987
9988               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9989                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9990               else
9991                 {
9992                   printf (": ");
9993                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9994                   putchar ('\n');
9995                 }
9996             }
9997           break;
9998
9999         case DT_FEATURE:
10000           if (do_dynamic)
10001             {
10002               printf (_("Flags:"));
10003
10004               if (entry->d_un.d_val == 0)
10005                 printf (_(" None\n"));
10006               else
10007                 {
10008                   unsigned long int val = entry->d_un.d_val;
10009
10010                   if (val & DTF_1_PARINIT)
10011                     {
10012                       printf (" PARINIT");
10013                       val ^= DTF_1_PARINIT;
10014                     }
10015                   if (val & DTF_1_CONFEXP)
10016                     {
10017                       printf (" CONFEXP");
10018                       val ^= DTF_1_CONFEXP;
10019                     }
10020                   if (val != 0)
10021                     printf (" %lx", val);
10022                   puts ("");
10023                 }
10024             }
10025           break;
10026
10027         case DT_POSFLAG_1:
10028           if (do_dynamic)
10029             {
10030               printf (_("Flags:"));
10031
10032               if (entry->d_un.d_val == 0)
10033                 printf (_(" None\n"));
10034               else
10035                 {
10036                   unsigned long int val = entry->d_un.d_val;
10037
10038                   if (val & DF_P1_LAZYLOAD)
10039                     {
10040                       printf (" LAZYLOAD");
10041                       val ^= DF_P1_LAZYLOAD;
10042                     }
10043                   if (val & DF_P1_GROUPPERM)
10044                     {
10045                       printf (" GROUPPERM");
10046                       val ^= DF_P1_GROUPPERM;
10047                     }
10048                   if (val != 0)
10049                     printf (" %lx", val);
10050                   puts ("");
10051                 }
10052             }
10053           break;
10054
10055         case DT_FLAGS_1:
10056           if (do_dynamic)
10057             {
10058               printf (_("Flags:"));
10059               if (entry->d_un.d_val == 0)
10060                 printf (_(" None\n"));
10061               else
10062                 {
10063                   unsigned long int val = entry->d_un.d_val;
10064
10065                   if (val & DF_1_NOW)
10066                     {
10067                       printf (" NOW");
10068                       val ^= DF_1_NOW;
10069                     }
10070                   if (val & DF_1_GLOBAL)
10071                     {
10072                       printf (" GLOBAL");
10073                       val ^= DF_1_GLOBAL;
10074                     }
10075                   if (val & DF_1_GROUP)
10076                     {
10077                       printf (" GROUP");
10078                       val ^= DF_1_GROUP;
10079                     }
10080                   if (val & DF_1_NODELETE)
10081                     {
10082                       printf (" NODELETE");
10083                       val ^= DF_1_NODELETE;
10084                     }
10085                   if (val & DF_1_LOADFLTR)
10086                     {
10087                       printf (" LOADFLTR");
10088                       val ^= DF_1_LOADFLTR;
10089                     }
10090                   if (val & DF_1_INITFIRST)
10091                     {
10092                       printf (" INITFIRST");
10093                       val ^= DF_1_INITFIRST;
10094                     }
10095                   if (val & DF_1_NOOPEN)
10096                     {
10097                       printf (" NOOPEN");
10098                       val ^= DF_1_NOOPEN;
10099                     }
10100                   if (val & DF_1_ORIGIN)
10101                     {
10102                       printf (" ORIGIN");
10103                       val ^= DF_1_ORIGIN;
10104                     }
10105                   if (val & DF_1_DIRECT)
10106                     {
10107                       printf (" DIRECT");
10108                       val ^= DF_1_DIRECT;
10109                     }
10110                   if (val & DF_1_TRANS)
10111                     {
10112                       printf (" TRANS");
10113                       val ^= DF_1_TRANS;
10114                     }
10115                   if (val & DF_1_INTERPOSE)
10116                     {
10117                       printf (" INTERPOSE");
10118                       val ^= DF_1_INTERPOSE;
10119                     }
10120                   if (val & DF_1_NODEFLIB)
10121                     {
10122                       printf (" NODEFLIB");
10123                       val ^= DF_1_NODEFLIB;
10124                     }
10125                   if (val & DF_1_NODUMP)
10126                     {
10127                       printf (" NODUMP");
10128                       val ^= DF_1_NODUMP;
10129                     }
10130                   if (val & DF_1_CONFALT)
10131                     {
10132                       printf (" CONFALT");
10133                       val ^= DF_1_CONFALT;
10134                     }
10135                   if (val & DF_1_ENDFILTEE)
10136                     {
10137                       printf (" ENDFILTEE");
10138                       val ^= DF_1_ENDFILTEE;
10139                     }
10140                   if (val & DF_1_DISPRELDNE)
10141                     {
10142                       printf (" DISPRELDNE");
10143                       val ^= DF_1_DISPRELDNE;
10144                     }
10145                   if (val & DF_1_DISPRELPND)
10146                     {
10147                       printf (" DISPRELPND");
10148                       val ^= DF_1_DISPRELPND;
10149                     }
10150                   if (val & DF_1_NODIRECT)
10151                     {
10152                       printf (" NODIRECT");
10153                       val ^= DF_1_NODIRECT;
10154                     }
10155                   if (val & DF_1_IGNMULDEF)
10156                     {
10157                       printf (" IGNMULDEF");
10158                       val ^= DF_1_IGNMULDEF;
10159                     }
10160                   if (val & DF_1_NOKSYMS)
10161                     {
10162                       printf (" NOKSYMS");
10163                       val ^= DF_1_NOKSYMS;
10164                     }
10165                   if (val & DF_1_NOHDR)
10166                     {
10167                       printf (" NOHDR");
10168                       val ^= DF_1_NOHDR;
10169                     }
10170                   if (val & DF_1_EDITED)
10171                     {
10172                       printf (" EDITED");
10173                       val ^= DF_1_EDITED;
10174                     }
10175                   if (val & DF_1_NORELOC)
10176                     {
10177                       printf (" NORELOC");
10178                       val ^= DF_1_NORELOC;
10179                     }
10180                   if (val & DF_1_SYMINTPOSE)
10181                     {
10182                       printf (" SYMINTPOSE");
10183                       val ^= DF_1_SYMINTPOSE;
10184                     }
10185                   if (val & DF_1_GLOBAUDIT)
10186                     {
10187                       printf (" GLOBAUDIT");
10188                       val ^= DF_1_GLOBAUDIT;
10189                     }
10190                   if (val & DF_1_SINGLETON)
10191                     {
10192                       printf (" SINGLETON");
10193                       val ^= DF_1_SINGLETON;
10194                     }
10195                   if (val & DF_1_STUB)
10196                     {
10197                       printf (" STUB");
10198                       val ^= DF_1_STUB;
10199                     }
10200                   if (val & DF_1_PIE)
10201                     {
10202                       printf (" PIE");
10203                       val ^= DF_1_PIE;
10204                     }
10205                   if (val & DF_1_KMOD)
10206                     {
10207                       printf (" KMOD");
10208                       val ^= DF_1_KMOD;
10209                     }
10210                   if (val & DF_1_WEAKFILTER)
10211                     {
10212                       printf (" WEAKFILTER");
10213                       val ^= DF_1_WEAKFILTER;
10214                     }
10215                   if (val & DF_1_NOCOMMON)
10216                     {
10217                       printf (" NOCOMMON");
10218                       val ^= DF_1_NOCOMMON;
10219                     }
10220                   if (val != 0)
10221                     printf (" %lx", val);
10222                   puts ("");
10223                 }
10224             }
10225           break;
10226
10227         case DT_PLTREL:
10228           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10229           if (do_dynamic)
10230             puts (get_dynamic_type (filedata, entry->d_un.d_val));
10231           break;
10232
10233         case DT_NULL    :
10234         case DT_NEEDED  :
10235         case DT_PLTGOT  :
10236         case DT_HASH    :
10237         case DT_STRTAB  :
10238         case DT_SYMTAB  :
10239         case DT_RELA    :
10240         case DT_INIT    :
10241         case DT_FINI    :
10242         case DT_SONAME  :
10243         case DT_RPATH   :
10244         case DT_SYMBOLIC:
10245         case DT_REL     :
10246         case DT_DEBUG   :
10247         case DT_TEXTREL :
10248         case DT_JMPREL  :
10249         case DT_RUNPATH :
10250           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10251
10252           if (do_dynamic)
10253             {
10254               char * name;
10255
10256               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10257                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10258               else
10259                 name = NULL;
10260
10261               if (name)
10262                 {
10263                   switch (entry->d_tag)
10264                     {
10265                     case DT_NEEDED:
10266                       printf (_("Shared library: [%s]"), name);
10267
10268                       if (streq (name, program_interpreter))
10269                         printf (_(" program interpreter"));
10270                       break;
10271
10272                     case DT_SONAME:
10273                       printf (_("Library soname: [%s]"), name);
10274                       break;
10275
10276                     case DT_RPATH:
10277                       printf (_("Library rpath: [%s]"), name);
10278                       break;
10279
10280                     case DT_RUNPATH:
10281                       printf (_("Library runpath: [%s]"), name);
10282                       break;
10283
10284                     default:
10285                       print_vma (entry->d_un.d_val, PREFIX_HEX);
10286                       break;
10287                     }
10288                 }
10289               else
10290                 print_vma (entry->d_un.d_val, PREFIX_HEX);
10291
10292               putchar ('\n');
10293             }
10294           break;
10295
10296         case DT_PLTRELSZ:
10297         case DT_RELASZ  :
10298         case DT_STRSZ   :
10299         case DT_RELSZ   :
10300         case DT_RELAENT :
10301         case DT_SYMENT  :
10302         case DT_RELENT  :
10303           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10304           /* Fall through.  */
10305         case DT_PLTPADSZ:
10306         case DT_MOVEENT :
10307         case DT_MOVESZ  :
10308         case DT_INIT_ARRAYSZ:
10309         case DT_FINI_ARRAYSZ:
10310         case DT_GNU_CONFLICTSZ:
10311         case DT_GNU_LIBLISTSZ:
10312           if (do_dynamic)
10313             {
10314               print_vma (entry->d_un.d_val, UNSIGNED);
10315               printf (_(" (bytes)\n"));
10316             }
10317           break;
10318
10319         case DT_VERDEFNUM:
10320         case DT_VERNEEDNUM:
10321         case DT_RELACOUNT:
10322         case DT_RELCOUNT:
10323           if (do_dynamic)
10324             {
10325               print_vma (entry->d_un.d_val, UNSIGNED);
10326               putchar ('\n');
10327             }
10328           break;
10329
10330         case DT_SYMINSZ:
10331         case DT_SYMINENT:
10332         case DT_SYMINFO:
10333         case DT_USED:
10334         case DT_INIT_ARRAY:
10335         case DT_FINI_ARRAY:
10336           if (do_dynamic)
10337             {
10338               if (entry->d_tag == DT_USED
10339                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10340                 {
10341                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10342
10343                   if (*name)
10344                     {
10345                       printf (_("Not needed object: [%s]\n"), name);
10346                       break;
10347                     }
10348                 }
10349
10350               print_vma (entry->d_un.d_val, PREFIX_HEX);
10351               putchar ('\n');
10352             }
10353           break;
10354
10355         case DT_BIND_NOW:
10356           /* The value of this entry is ignored.  */
10357           if (do_dynamic)
10358             putchar ('\n');
10359           break;
10360
10361         case DT_GNU_PRELINKED:
10362           if (do_dynamic)
10363             {
10364               struct tm * tmp;
10365               time_t atime = entry->d_un.d_val;
10366
10367               tmp = gmtime (&atime);
10368               /* PR 17533 file: 041-1244816-0.004.  */
10369               if (tmp == NULL)
10370                 printf (_("<corrupt time val: %lx"),
10371                         (unsigned long) atime);
10372               else
10373                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10374                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10375                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10376
10377             }
10378           break;
10379
10380         case DT_GNU_HASH:
10381           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10382           if (do_dynamic)
10383             {
10384               print_vma (entry->d_un.d_val, PREFIX_HEX);
10385               putchar ('\n');
10386             }
10387           break;
10388
10389         default:
10390           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10391             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10392               entry->d_un.d_val;
10393
10394           if (do_dynamic)
10395             {
10396               switch (filedata->file_header.e_machine)
10397                 {
10398                 case EM_AARCH64:
10399                   dynamic_section_aarch64_val (entry);
10400                   break;
10401                 case EM_MIPS:
10402                 case EM_MIPS_RS3_LE:
10403                   dynamic_section_mips_val (entry);
10404                   break;
10405                 case EM_PARISC:
10406                   dynamic_section_parisc_val (entry);
10407                   break;
10408                 case EM_IA_64:
10409                   dynamic_section_ia64_val (entry);
10410                   break;
10411                 default:
10412                   print_vma (entry->d_un.d_val, PREFIX_HEX);
10413                   putchar ('\n');
10414                 }
10415             }
10416           break;
10417         }
10418     }
10419
10420   return TRUE;
10421 }
10422
10423 static char *
10424 get_ver_flags (unsigned int flags)
10425 {
10426   static char buff[128];
10427
10428   buff[0] = 0;
10429
10430   if (flags == 0)
10431     return _("none");
10432
10433   if (flags & VER_FLG_BASE)
10434     strcat (buff, "BASE");
10435
10436   if (flags & VER_FLG_WEAK)
10437     {
10438       if (flags & VER_FLG_BASE)
10439         strcat (buff, " | ");
10440
10441       strcat (buff, "WEAK");
10442     }
10443
10444   if (flags & VER_FLG_INFO)
10445     {
10446       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10447         strcat (buff, " | ");
10448
10449       strcat (buff, "INFO");
10450     }
10451
10452   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10453     {
10454       if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10455         strcat (buff, " | ");
10456
10457       strcat (buff, _("<unknown>"));
10458     }
10459
10460   return buff;
10461 }
10462
10463 /* Display the contents of the version sections.  */
10464
10465 static bfd_boolean
10466 process_version_sections (Filedata * filedata)
10467 {
10468   Elf_Internal_Shdr * section;
10469   unsigned i;
10470   bfd_boolean found = FALSE;
10471
10472   if (! do_version)
10473     return TRUE;
10474
10475   for (i = 0, section = filedata->section_headers;
10476        i < filedata->file_header.e_shnum;
10477        i++, section++)
10478     {
10479       switch (section->sh_type)
10480         {
10481         case SHT_GNU_verdef:
10482           {
10483             Elf_External_Verdef * edefs;
10484             unsigned long idx;
10485             unsigned long cnt;
10486             char * endbuf;
10487
10488             found = TRUE;
10489
10490             printf (ngettext ("\nVersion definition section '%s' "
10491                               "contains %u entry:\n",
10492                               "\nVersion definition section '%s' "
10493                               "contains %u entries:\n",
10494                               section->sh_info),
10495                     printable_section_name (filedata, section),
10496                     section->sh_info);
10497
10498             printf (_("  Addr: 0x"));
10499             printf_vma (section->sh_addr);
10500             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10501                     (unsigned long) section->sh_offset, section->sh_link,
10502                     printable_section_name_from_index (filedata, section->sh_link));
10503
10504             edefs = (Elf_External_Verdef *)
10505                 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
10506                           _("version definition section"));
10507             if (!edefs)
10508               break;
10509             endbuf = (char *) edefs + section->sh_size;
10510
10511             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10512               {
10513                 char * vstart;
10514                 Elf_External_Verdef * edef;
10515                 Elf_Internal_Verdef ent;
10516                 Elf_External_Verdaux * eaux;
10517                 Elf_Internal_Verdaux aux;
10518                 unsigned long isum;
10519                 int j;
10520
10521                 vstart = ((char *) edefs) + idx;
10522                 if (vstart + sizeof (*edef) > endbuf)
10523                   break;
10524
10525                 edef = (Elf_External_Verdef *) vstart;
10526
10527                 ent.vd_version = BYTE_GET (edef->vd_version);
10528                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
10529                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
10530                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
10531                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
10532                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
10533                 ent.vd_next    = BYTE_GET (edef->vd_next);
10534
10535                 printf (_("  %#06lx: Rev: %d  Flags: %s"),
10536                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10537
10538                 printf (_("  Index: %d  Cnt: %d  "),
10539                         ent.vd_ndx, ent.vd_cnt);
10540
10541                 /* Check for overflow.  */
10542                 if (ent.vd_aux > (size_t) (endbuf - vstart))
10543                   break;
10544
10545                 vstart += ent.vd_aux;
10546
10547                 if (vstart + sizeof (*eaux) > endbuf)
10548                   break;
10549                 eaux = (Elf_External_Verdaux *) vstart;
10550
10551                 aux.vda_name = BYTE_GET (eaux->vda_name);
10552                 aux.vda_next = BYTE_GET (eaux->vda_next);
10553
10554                 if (VALID_DYNAMIC_NAME (aux.vda_name))
10555                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10556                 else
10557                   printf (_("Name index: %ld\n"), aux.vda_name);
10558
10559                 isum = idx + ent.vd_aux;
10560
10561                 for (j = 1; j < ent.vd_cnt; j++)
10562                   {
10563                     if (aux.vda_next < sizeof (*eaux)
10564                         && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10565                       {
10566                         warn (_("Invalid vda_next field of %lx\n"),
10567                               aux.vda_next);
10568                         j = ent.vd_cnt;
10569                         break;
10570                       }
10571                     /* Check for overflow.  */
10572                     if (aux.vda_next > (size_t) (endbuf - vstart))
10573                       break;
10574
10575                     isum   += aux.vda_next;
10576                     vstart += aux.vda_next;
10577
10578                     if (vstart + sizeof (*eaux) > endbuf)
10579                       break;
10580                     eaux = (Elf_External_Verdaux *) vstart;
10581
10582                     aux.vda_name = BYTE_GET (eaux->vda_name);
10583                     aux.vda_next = BYTE_GET (eaux->vda_next);
10584
10585                     if (VALID_DYNAMIC_NAME (aux.vda_name))
10586                       printf (_("  %#06lx: Parent %d: %s\n"),
10587                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10588                     else
10589                       printf (_("  %#06lx: Parent %d, name index: %ld\n"),
10590                               isum, j, aux.vda_name);
10591                   }
10592
10593                 if (j < ent.vd_cnt)
10594                   printf (_("  Version def aux past end of section\n"));
10595
10596                 /* PR 17531:
10597                    file: id:000001,src:000172+005151,op:splice,rep:2.  */
10598                 if (ent.vd_next < sizeof (*edef)
10599                     && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10600                   {
10601                     warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10602                     cnt = section->sh_info;
10603                     break;
10604                   }
10605                 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10606                   break;
10607
10608                 idx += ent.vd_next;
10609               }
10610
10611             if (cnt < section->sh_info)
10612               printf (_("  Version definition past end of section\n"));
10613
10614             free (edefs);
10615           }
10616           break;
10617
10618         case SHT_GNU_verneed:
10619           {
10620             Elf_External_Verneed * eneed;
10621             unsigned long idx;
10622             unsigned long cnt;
10623             char * endbuf;
10624
10625             found = TRUE;
10626
10627             printf (ngettext ("\nVersion needs section '%s' "
10628                               "contains %u entry:\n",
10629                               "\nVersion needs section '%s' "
10630                               "contains %u entries:\n",
10631                               section->sh_info),
10632                     printable_section_name (filedata, section), section->sh_info);
10633
10634             printf (_(" Addr: 0x"));
10635             printf_vma (section->sh_addr);
10636             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10637                     (unsigned long) section->sh_offset, section->sh_link,
10638                     printable_section_name_from_index (filedata, section->sh_link));
10639
10640             eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
10641                                                        section->sh_offset, 1,
10642                                                        section->sh_size,
10643                                                        _("Version Needs section"));
10644             if (!eneed)
10645               break;
10646             endbuf = (char *) eneed + section->sh_size;
10647
10648             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10649               {
10650                 Elf_External_Verneed * entry;
10651                 Elf_Internal_Verneed ent;
10652                 unsigned long isum;
10653                 int j;
10654                 char * vstart;
10655
10656                 vstart = ((char *) eneed) + idx;
10657                 if (vstart + sizeof (*entry) > endbuf)
10658                   break;
10659
10660                 entry = (Elf_External_Verneed *) vstart;
10661
10662                 ent.vn_version = BYTE_GET (entry->vn_version);
10663                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
10664                 ent.vn_file    = BYTE_GET (entry->vn_file);
10665                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
10666                 ent.vn_next    = BYTE_GET (entry->vn_next);
10667
10668                 printf (_("  %#06lx: Version: %d"), idx, ent.vn_version);
10669
10670                 if (VALID_DYNAMIC_NAME (ent.vn_file))
10671                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10672                 else
10673                   printf (_("  File: %lx"), ent.vn_file);
10674
10675                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
10676
10677                 /* Check for overflow.  */
10678                 if (ent.vn_aux > (size_t) (endbuf - vstart))
10679                   break;
10680                 vstart += ent.vn_aux;
10681
10682                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10683                   {
10684                     Elf_External_Vernaux * eaux;
10685                     Elf_Internal_Vernaux aux;
10686
10687                     if (vstart + sizeof (*eaux) > endbuf)
10688                       break;
10689                     eaux = (Elf_External_Vernaux *) vstart;
10690
10691                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
10692                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
10693                     aux.vna_other = BYTE_GET (eaux->vna_other);
10694                     aux.vna_name  = BYTE_GET (eaux->vna_name);
10695                     aux.vna_next  = BYTE_GET (eaux->vna_next);
10696
10697                     if (VALID_DYNAMIC_NAME (aux.vna_name))
10698                       printf (_("  %#06lx:   Name: %s"),
10699                               isum, GET_DYNAMIC_NAME (aux.vna_name));
10700                     else
10701                       printf (_("  %#06lx:   Name index: %lx"),
10702                               isum, aux.vna_name);
10703
10704                     printf (_("  Flags: %s  Version: %d\n"),
10705                             get_ver_flags (aux.vna_flags), aux.vna_other);
10706
10707                     if (aux.vna_next < sizeof (*eaux)
10708                         && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10709                       {
10710                         warn (_("Invalid vna_next field of %lx\n"),
10711                               aux.vna_next);
10712                         j = ent.vn_cnt;
10713                         break;
10714                       }
10715                     /* Check for overflow.  */
10716                     if (aux.vna_next > (size_t) (endbuf - vstart))
10717                       break;
10718                     isum   += aux.vna_next;
10719                     vstart += aux.vna_next;
10720                   }
10721
10722                 if (j < ent.vn_cnt)
10723                   warn (_("Missing Version Needs auxillary information\n"));
10724
10725                 if (ent.vn_next < sizeof (*entry)
10726                     && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10727                   {
10728                     warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10729                     cnt = section->sh_info;
10730                     break;
10731                   }
10732                 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10733                   break;
10734                 idx += ent.vn_next;
10735               }
10736
10737             if (cnt < section->sh_info)
10738               warn (_("Missing Version Needs information\n"));
10739
10740             free (eneed);
10741           }
10742           break;
10743
10744         case SHT_GNU_versym:
10745           {
10746             Elf_Internal_Shdr * link_section;
10747             size_t total;
10748             unsigned int cnt;
10749             unsigned char * edata;
10750             unsigned short * data;
10751             char * strtab;
10752             Elf_Internal_Sym * symbols;
10753             Elf_Internal_Shdr * string_sec;
10754             unsigned long num_syms;
10755             long off;
10756
10757             if (section->sh_link >= filedata->file_header.e_shnum)
10758               break;
10759
10760             link_section = filedata->section_headers + section->sh_link;
10761             total = section->sh_size / sizeof (Elf_External_Versym);
10762
10763             if (link_section->sh_link >= filedata->file_header.e_shnum)
10764               break;
10765
10766             found = TRUE;
10767
10768             symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
10769             if (symbols == NULL)
10770               break;
10771
10772             string_sec = filedata->section_headers + link_section->sh_link;
10773
10774             strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
10775                                         string_sec->sh_size,
10776                                         _("version string table"));
10777             if (!strtab)
10778               {
10779                 free (symbols);
10780                 break;
10781               }
10782
10783             printf (ngettext ("\nVersion symbols section '%s' "
10784                               "contains %lu entry:\n",
10785                               "\nVersion symbols section '%s' "
10786                               "contains %lu entries:\n",
10787                               total),
10788                     printable_section_name (filedata, section), (unsigned long) total);
10789
10790             printf (_(" Addr: "));
10791             printf_vma (section->sh_addr);
10792             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10793                     (unsigned long) section->sh_offset, section->sh_link,
10794                     printable_section_name (filedata, link_section));
10795
10796             off = offset_from_vma (filedata,
10797                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10798                                    total * sizeof (short));
10799             edata = (unsigned char *) get_data (NULL, filedata, off, total,
10800                                                 sizeof (short),
10801                                                 _("version symbol data"));
10802             if (!edata)
10803               {
10804                 free (strtab);
10805                 free (symbols);
10806                 break;
10807               }
10808
10809             data = (short unsigned int *) cmalloc (total, sizeof (short));
10810
10811             for (cnt = total; cnt --;)
10812               data[cnt] = byte_get (edata + cnt * sizeof (short),
10813                                     sizeof (short));
10814
10815             free (edata);
10816
10817             for (cnt = 0; cnt < total; cnt += 4)
10818               {
10819                 int j, nn;
10820                 char *name;
10821                 char *invalid = _("*invalid*");
10822
10823                 printf ("  %03x:", cnt);
10824
10825                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10826                   switch (data[cnt + j])
10827                     {
10828                     case 0:
10829                       fputs (_("   0 (*local*)    "), stdout);
10830                       break;
10831
10832                     case 1:
10833                       fputs (_("   1 (*global*)   "), stdout);
10834                       break;
10835
10836                     default:
10837                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10838                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10839
10840                       /* If this index value is greater than the size of the symbols
10841                          array, break to avoid an out-of-bounds read.  */
10842                       if ((unsigned long)(cnt + j) >= num_syms)
10843                         {
10844                           warn (_("invalid index into symbol array\n"));
10845                           break;
10846                         }
10847
10848                       name = NULL;
10849                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10850                         {
10851                           Elf_Internal_Verneed ivn;
10852                           unsigned long offset;
10853
10854                           offset = offset_from_vma
10855                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10856                              sizeof (Elf_External_Verneed));
10857
10858                           do
10859                             {
10860                               Elf_Internal_Vernaux ivna;
10861                               Elf_External_Verneed evn;
10862                               Elf_External_Vernaux evna;
10863                               unsigned long a_off;
10864
10865                               if (get_data (&evn, filedata, offset, sizeof (evn), 1,
10866                                             _("version need")) == NULL)
10867                                 break;
10868
10869                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10870                               ivn.vn_next = BYTE_GET (evn.vn_next);
10871
10872                               a_off = offset + ivn.vn_aux;
10873
10874                               do
10875                                 {
10876                                   if (get_data (&evna, filedata, a_off, sizeof (evna),
10877                                                 1, _("version need aux (2)")) == NULL)
10878                                     {
10879                                       ivna.vna_next  = 0;
10880                                       ivna.vna_other = 0;
10881                                     }
10882                                   else
10883                                     {
10884                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
10885                                       ivna.vna_other = BYTE_GET (evna.vna_other);
10886                                     }
10887
10888                                   a_off += ivna.vna_next;
10889                                 }
10890                               while (ivna.vna_other != data[cnt + j]
10891                                      && ivna.vna_next != 0);
10892
10893                               if (ivna.vna_other == data[cnt + j])
10894                                 {
10895                                   ivna.vna_name = BYTE_GET (evna.vna_name);
10896
10897                                   if (ivna.vna_name >= string_sec->sh_size)
10898                                     name = invalid;
10899                                   else
10900                                     name = strtab + ivna.vna_name;
10901                                   break;
10902                                 }
10903
10904                               offset += ivn.vn_next;
10905                             }
10906                           while (ivn.vn_next);
10907                         }
10908
10909                       if (data[cnt + j] != 0x8001
10910                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10911                         {
10912                           Elf_Internal_Verdef ivd;
10913                           Elf_External_Verdef evd;
10914                           unsigned long offset;
10915
10916                           offset = offset_from_vma
10917                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10918                              sizeof evd);
10919
10920                           do
10921                             {
10922                               if (get_data (&evd, filedata, offset, sizeof (evd), 1,
10923                                             _("version def")) == NULL)
10924                                 {
10925                                   ivd.vd_next = 0;
10926                                   /* PR 17531: file: 046-1082287-0.004.  */
10927                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
10928                                   break;
10929                                 }
10930                               else
10931                                 {
10932                                   ivd.vd_next = BYTE_GET (evd.vd_next);
10933                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
10934                                 }
10935
10936                               offset += ivd.vd_next;
10937                             }
10938                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10939                                  && ivd.vd_next != 0);
10940
10941                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10942                             {
10943                               Elf_External_Verdaux evda;
10944                               Elf_Internal_Verdaux ivda;
10945
10946                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
10947
10948                               if (get_data (&evda, filedata,
10949                                             offset - ivd.vd_next + ivd.vd_aux,
10950                                             sizeof (evda), 1,
10951                                             _("version def aux")) == NULL)
10952                                 break;
10953
10954                               ivda.vda_name = BYTE_GET (evda.vda_name);
10955
10956                               if (ivda.vda_name >= string_sec->sh_size)
10957                                 name = invalid;
10958                               else if (name != NULL && name != invalid)
10959                                 name = _("*both*");
10960                               else
10961                                 name = strtab + ivda.vda_name;
10962                             }
10963                         }
10964                       if (name != NULL)
10965                         nn += printf ("(%s%-*s",
10966                                       name,
10967                                       12 - (int) strlen (name),
10968                                       ")");
10969
10970                       if (nn < 18)
10971                         printf ("%*c", 18 - nn, ' ');
10972                     }
10973
10974                 putchar ('\n');
10975               }
10976
10977             free (data);
10978             free (strtab);
10979             free (symbols);
10980           }
10981           break;
10982
10983         default:
10984           break;
10985         }
10986     }
10987
10988   if (! found)
10989     printf (_("\nNo version information found in this file.\n"));
10990
10991   return TRUE;
10992 }
10993
10994 static const char *
10995 get_symbol_binding (Filedata * filedata, unsigned int binding)
10996 {
10997   static char buff[32];
10998
10999   switch (binding)
11000     {
11001     case STB_LOCAL:     return "LOCAL";
11002     case STB_GLOBAL:    return "GLOBAL";
11003     case STB_WEAK:      return "WEAK";
11004     default:
11005       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
11006         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
11007                   binding);
11008       else if (binding >= STB_LOOS && binding <= STB_HIOS)
11009         {
11010           if (binding == STB_GNU_UNIQUE
11011               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
11012                   /* GNU is still using the default value 0.  */
11013                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
11014             return "UNIQUE";
11015           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
11016         }
11017       else
11018         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
11019       return buff;
11020     }
11021 }
11022
11023 static const char *
11024 get_symbol_type (Filedata * filedata, unsigned int type)
11025 {
11026   static char buff[32];
11027
11028   switch (type)
11029     {
11030     case STT_NOTYPE:    return "NOTYPE";
11031     case STT_OBJECT:    return "OBJECT";
11032     case STT_FUNC:      return "FUNC";
11033     case STT_SECTION:   return "SECTION";
11034     case STT_FILE:      return "FILE";
11035     case STT_COMMON:    return "COMMON";
11036     case STT_TLS:       return "TLS";
11037     case STT_RELC:      return "RELC";
11038     case STT_SRELC:     return "SRELC";
11039     default:
11040       if (type >= STT_LOPROC && type <= STT_HIPROC)
11041         {
11042           if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
11043             return "THUMB_FUNC";
11044
11045           if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
11046             return "REGISTER";
11047
11048           if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
11049             return "PARISC_MILLI";
11050
11051           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
11052         }
11053       else if (type >= STT_LOOS && type <= STT_HIOS)
11054         {
11055           if (filedata->file_header.e_machine == EM_PARISC)
11056             {
11057               if (type == STT_HP_OPAQUE)
11058                 return "HP_OPAQUE";
11059               if (type == STT_HP_STUB)
11060                 return "HP_STUB";
11061             }
11062
11063           if (type == STT_GNU_IFUNC
11064               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
11065                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
11066                   /* GNU is still using the default value 0.  */
11067                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
11068             return "IFUNC";
11069
11070           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
11071         }
11072       else
11073         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
11074       return buff;
11075     }
11076 }
11077
11078 static const char *
11079 get_symbol_visibility (unsigned int visibility)
11080 {
11081   switch (visibility)
11082     {
11083     case STV_DEFAULT:   return "DEFAULT";
11084     case STV_INTERNAL:  return "INTERNAL";
11085     case STV_HIDDEN:    return "HIDDEN";
11086     case STV_PROTECTED: return "PROTECTED";
11087     default:
11088       error (_("Unrecognized visibility value: %u"), visibility);
11089       return _("<unknown>");
11090     }
11091 }
11092
11093 static const char *
11094 get_solaris_symbol_visibility (unsigned int visibility)
11095 {
11096   switch (visibility)
11097     {
11098     case 4: return "EXPORTED";
11099     case 5: return "SINGLETON";
11100     case 6: return "ELIMINATE";
11101     default: return get_symbol_visibility (visibility);
11102     }
11103 }
11104
11105 static const char *
11106 get_aarch64_symbol_other (unsigned int other)
11107 {
11108   static char buf[32];
11109
11110   if (other & STO_AARCH64_VARIANT_PCS)
11111     {
11112       other &= ~STO_AARCH64_VARIANT_PCS;
11113       if (other == 0)
11114         return "VARIANT_PCS";
11115       snprintf (buf, sizeof buf, "VARIANT_PCS | %x", other);
11116       return buf;
11117     }
11118   return NULL;
11119 }
11120
11121 static const char *
11122 get_mips_symbol_other (unsigned int other)
11123 {
11124   switch (other)
11125     {
11126     case STO_OPTIONAL:      return "OPTIONAL";
11127     case STO_MIPS_PLT:      return "MIPS PLT";
11128     case STO_MIPS_PIC:      return "MIPS PIC";
11129     case STO_MICROMIPS:     return "MICROMIPS";
11130     case STO_MICROMIPS | STO_MIPS_PIC:      return "MICROMIPS, MIPS PIC";
11131     case STO_MIPS16:        return "MIPS16";
11132     default:                return NULL;
11133     }
11134 }
11135
11136 static const char *
11137 get_ia64_symbol_other (Filedata * filedata, unsigned int other)
11138 {
11139   if (is_ia64_vms (filedata))
11140     {
11141       static char res[32];
11142
11143       res[0] = 0;
11144
11145       /* Function types is for images and .STB files only.  */
11146       switch (filedata->file_header.e_type)
11147         {
11148         case ET_DYN:
11149         case ET_EXEC:
11150           switch (VMS_ST_FUNC_TYPE (other))
11151             {
11152             case VMS_SFT_CODE_ADDR:
11153               strcat (res, " CA");
11154               break;
11155             case VMS_SFT_SYMV_IDX:
11156               strcat (res, " VEC");
11157               break;
11158             case VMS_SFT_FD:
11159               strcat (res, " FD");
11160               break;
11161             case VMS_SFT_RESERVE:
11162               strcat (res, " RSV");
11163               break;
11164             default:
11165               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11166                     VMS_ST_FUNC_TYPE (other));
11167               strcat (res, " <unknown>");
11168               break;
11169             }
11170           break;
11171         default:
11172           break;
11173         }
11174       switch (VMS_ST_LINKAGE (other))
11175         {
11176         case VMS_STL_IGNORE:
11177           strcat (res, " IGN");
11178           break;
11179         case VMS_STL_RESERVE:
11180           strcat (res, " RSV");
11181           break;
11182         case VMS_STL_STD:
11183           strcat (res, " STD");
11184           break;
11185         case VMS_STL_LNK:
11186           strcat (res, " LNK");
11187           break;
11188         default:
11189           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11190                 VMS_ST_LINKAGE (other));
11191           strcat (res, " <unknown>");
11192           break;
11193         }
11194
11195       if (res[0] != 0)
11196         return res + 1;
11197       else
11198         return res;
11199     }
11200   return NULL;
11201 }
11202
11203 static const char *
11204 get_ppc64_symbol_other (unsigned int other)
11205 {
11206   if ((other & ~STO_PPC64_LOCAL_MASK) != 0)
11207     return NULL;
11208
11209   other >>= STO_PPC64_LOCAL_BIT;
11210   if (other <= 6)
11211     {
11212       static char buf[32];
11213       if (other >= 2)
11214         other = ppc64_decode_local_entry (other);
11215       snprintf (buf, sizeof buf, _("<localentry>: %d"), other);
11216       return buf;
11217     }
11218   return NULL;
11219 }
11220
11221 static const char *
11222 get_symbol_other (Filedata * filedata, unsigned int other)
11223 {
11224   const char * result = NULL;
11225   static char buff [32];
11226
11227   if (other == 0)
11228     return "";
11229
11230   switch (filedata->file_header.e_machine)
11231     {
11232     case EM_AARCH64:
11233       result = get_aarch64_symbol_other (other);
11234       break;
11235     case EM_MIPS:
11236       result = get_mips_symbol_other (other);
11237       break;
11238     case EM_IA_64:
11239       result = get_ia64_symbol_other (filedata, other);
11240       break;
11241     case EM_PPC64:
11242       result = get_ppc64_symbol_other (other);
11243       break;
11244     default:
11245       result = NULL;
11246       break;
11247     }
11248
11249   if (result)
11250     return result;
11251
11252   snprintf (buff, sizeof buff, _("<other>: %x"), other);
11253   return buff;
11254 }
11255
11256 static const char *
11257 get_symbol_index_type (Filedata * filedata, unsigned int type)
11258 {
11259   static char buff[32];
11260
11261   switch (type)
11262     {
11263     case SHN_UNDEF:     return "UND";
11264     case SHN_ABS:       return "ABS";
11265     case SHN_COMMON:    return "COM";
11266     default:
11267       if (type == SHN_IA_64_ANSI_COMMON
11268           && filedata->file_header.e_machine == EM_IA_64
11269           && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11270         return "ANSI_COM";
11271       else if ((filedata->file_header.e_machine == EM_X86_64
11272                 || filedata->file_header.e_machine == EM_L1OM
11273                 || filedata->file_header.e_machine == EM_K1OM)
11274                && type == SHN_X86_64_LCOMMON)
11275         return "LARGE_COM";
11276       else if ((type == SHN_MIPS_SCOMMON
11277                 && filedata->file_header.e_machine == EM_MIPS)
11278                || (type == SHN_TIC6X_SCOMMON
11279                    && filedata->file_header.e_machine == EM_TI_C6000))
11280         return "SCOM";
11281       else if (type == SHN_MIPS_SUNDEFINED
11282                && filedata->file_header.e_machine == EM_MIPS)
11283         return "SUND";
11284       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11285         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11286       else if (type >= SHN_LOOS && type <= SHN_HIOS)
11287         sprintf (buff, "OS [0x%04x]", type & 0xffff);
11288       else if (type >= SHN_LORESERVE)
11289         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11290       else if (type >= filedata->file_header.e_shnum)
11291         sprintf (buff, _("bad section index[%3d]"), type);
11292       else
11293         sprintf (buff, "%3d", type);
11294       break;
11295     }
11296
11297   return buff;
11298 }
11299
11300 static bfd_vma *
11301 get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
11302 {
11303   unsigned char * e_data;
11304   bfd_vma * i_data;
11305
11306   /* If the size_t type is smaller than the bfd_size_type, eg because
11307      you are building a 32-bit tool on a 64-bit host, then make sure
11308      that when (number) is cast to (size_t) no information is lost.  */
11309   if (sizeof (size_t) < sizeof (bfd_size_type)
11310       && (bfd_size_type) ((size_t) number) != number)
11311     {
11312       error (_("Size truncation prevents reading %s elements of size %u\n"),
11313              bfd_vmatoa ("u", number), ent_size);
11314       return NULL;
11315     }
11316
11317   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11318      attempting to allocate memory when the read is bound to fail.  */
11319   if (ent_size * number > filedata->file_size)
11320     {
11321       error (_("Invalid number of dynamic entries: %s\n"),
11322              bfd_vmatoa ("u", number));
11323       return NULL;
11324     }
11325
11326   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11327   if (e_data == NULL)
11328     {
11329       error (_("Out of memory reading %s dynamic entries\n"),
11330              bfd_vmatoa ("u", number));
11331       return NULL;
11332     }
11333
11334   if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
11335     {
11336       error (_("Unable to read in %s bytes of dynamic data\n"),
11337              bfd_vmatoa ("u", number * ent_size));
11338       free (e_data);
11339       return NULL;
11340     }
11341
11342   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11343   if (i_data == NULL)
11344     {
11345       error (_("Out of memory allocating space for %s dynamic entries\n"),
11346              bfd_vmatoa ("u", number));
11347       free (e_data);
11348       return NULL;
11349     }
11350
11351   while (number--)
11352     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11353
11354   free (e_data);
11355
11356   return i_data;
11357 }
11358
11359 static void
11360 print_dynamic_symbol (Filedata * filedata, bfd_vma si, unsigned long hn)
11361 {
11362   Elf_Internal_Sym * psym;
11363   int n;
11364
11365   n = print_vma (si, DEC_5);
11366   if (n < 5)
11367     fputs (&"     "[n], stdout);
11368   printf (" %3lu: ", hn);
11369
11370   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11371     {
11372       printf (_("<No info available for dynamic symbol number %lu>\n"),
11373               (unsigned long) si);
11374       return;
11375     }
11376
11377   psym = dynamic_symbols + si;
11378   print_vma (psym->st_value, LONG_HEX);
11379   putchar (' ');
11380   print_vma (psym->st_size, DEC_5);
11381
11382   printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11383   printf (" %-6s",  get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11384
11385   if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11386     printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11387   else
11388     {
11389       unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11390
11391       printf (" %-7s",  get_symbol_visibility (vis));
11392       /* Check to see if any other bits in the st_other field are set.
11393          Note - displaying this information disrupts the layout of the
11394          table being generated, but for the moment this case is very
11395          rare.  */
11396       if (psym->st_other ^ vis)
11397         printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11398     }
11399
11400   printf (" %3.3s ", get_symbol_index_type (filedata, psym->st_shndx));
11401   if (VALID_DYNAMIC_NAME (psym->st_name))
11402     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11403   else
11404     printf (_(" <corrupt: %14ld>"), psym->st_name);
11405   putchar ('\n');
11406 }
11407
11408 static const char *
11409 get_symbol_version_string (Filedata *                   filedata,
11410                            bfd_boolean                  is_dynsym,
11411                            const char *                 strtab,
11412                            unsigned long int            strtab_size,
11413                            unsigned int                 si,
11414                            Elf_Internal_Sym *           psym,
11415                            enum versioned_symbol_info * sym_info,
11416                            unsigned short *             vna_other)
11417 {
11418   unsigned char data[2];
11419   unsigned short vers_data;
11420   unsigned long offset;
11421   unsigned short max_vd_ndx;
11422
11423   if (!is_dynsym
11424       || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11425     return NULL;
11426
11427   offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11428                             sizeof data + si * sizeof (vers_data));
11429
11430   if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11431                 sizeof (data), 1, _("version data")) == NULL)
11432     return NULL;
11433
11434   vers_data = byte_get (data, 2);
11435
11436   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data == 0)
11437     return NULL;
11438
11439   max_vd_ndx = 0;
11440
11441   /* Usually we'd only see verdef for defined symbols, and verneed for
11442      undefined symbols.  However, symbols defined by the linker in
11443      .dynbss for variables copied from a shared library in order to
11444      avoid text relocations are defined yet have verneed.  We could
11445      use a heuristic to detect the special case, for example, check
11446      for verneed first on symbols defined in SHT_NOBITS sections, but
11447      it is simpler and more reliable to just look for both verdef and
11448      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
11449
11450   if (psym->st_shndx != SHN_UNDEF
11451       && vers_data != 0x8001
11452       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11453     {
11454       Elf_Internal_Verdef ivd;
11455       Elf_Internal_Verdaux ivda;
11456       Elf_External_Verdaux evda;
11457       unsigned long off;
11458
11459       off = offset_from_vma (filedata,
11460                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11461                              sizeof (Elf_External_Verdef));
11462
11463       do
11464         {
11465           Elf_External_Verdef evd;
11466
11467           if (get_data (&evd, filedata, off, sizeof (evd), 1,
11468                         _("version def")) == NULL)
11469             {
11470               ivd.vd_ndx = 0;
11471               ivd.vd_aux = 0;
11472               ivd.vd_next = 0;
11473               ivd.vd_flags = 0;
11474             }
11475           else
11476             {
11477               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11478               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11479               ivd.vd_next = BYTE_GET (evd.vd_next);
11480               ivd.vd_flags = BYTE_GET (evd.vd_flags);
11481             }
11482
11483           if ((ivd.vd_ndx & VERSYM_VERSION) > max_vd_ndx)
11484             max_vd_ndx = ivd.vd_ndx & VERSYM_VERSION;
11485
11486           off += ivd.vd_next;
11487         }
11488       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11489
11490       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11491         {
11492           if (ivd.vd_ndx == 1 && ivd.vd_flags == VER_FLG_BASE)
11493             return NULL;
11494
11495           off -= ivd.vd_next;
11496           off += ivd.vd_aux;
11497
11498           if (get_data (&evda, filedata, off, sizeof (evda), 1,
11499                         _("version def aux")) != NULL)
11500             {
11501               ivda.vda_name = BYTE_GET (evda.vda_name);
11502
11503               if (psym->st_name != ivda.vda_name)
11504                 {
11505                   *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11506                                ? symbol_hidden : symbol_public);
11507                   return (ivda.vda_name < strtab_size
11508                           ? strtab + ivda.vda_name : _("<corrupt>"));
11509                 }
11510             }
11511         }
11512     }
11513
11514   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11515     {
11516       Elf_External_Verneed evn;
11517       Elf_Internal_Verneed ivn;
11518       Elf_Internal_Vernaux ivna;
11519
11520       offset = offset_from_vma (filedata,
11521                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11522                                 sizeof evn);
11523       do
11524         {
11525           unsigned long vna_off;
11526
11527           if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11528                         _("version need")) == NULL)
11529             {
11530               ivna.vna_next = 0;
11531               ivna.vna_other = 0;
11532               ivna.vna_name = 0;
11533               break;
11534             }
11535
11536           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
11537           ivn.vn_next = BYTE_GET (evn.vn_next);
11538
11539           vna_off = offset + ivn.vn_aux;
11540
11541           do
11542             {
11543               Elf_External_Vernaux evna;
11544
11545               if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11546                             _("version need aux (3)")) == NULL)
11547                 {
11548                   ivna.vna_next = 0;
11549                   ivna.vna_other = 0;
11550                   ivna.vna_name = 0;
11551                 }
11552               else
11553                 {
11554                   ivna.vna_other = BYTE_GET (evna.vna_other);
11555                   ivna.vna_next  = BYTE_GET (evna.vna_next);
11556                   ivna.vna_name  = BYTE_GET (evna.vna_name);
11557                 }
11558
11559               vna_off += ivna.vna_next;
11560             }
11561           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11562
11563           if (ivna.vna_other == vers_data)
11564             break;
11565
11566           offset += ivn.vn_next;
11567         }
11568       while (ivn.vn_next != 0);
11569
11570       if (ivna.vna_other == vers_data)
11571         {
11572           *sym_info = symbol_undefined;
11573           *vna_other = ivna.vna_other;
11574           return (ivna.vna_name < strtab_size
11575                   ? strtab + ivna.vna_name : _("<corrupt>"));
11576         }
11577       else if ((max_vd_ndx || (vers_data & VERSYM_VERSION) != 1)
11578                && (vers_data & VERSYM_VERSION) > max_vd_ndx)
11579         return _("<corrupt>");
11580     }
11581   return NULL;
11582 }
11583
11584 /* Dump the symbol table.  */
11585 static bfd_boolean
11586 process_symbol_table (Filedata * filedata)
11587 {
11588   Elf_Internal_Shdr * section;
11589   bfd_size_type nbuckets = 0;
11590   bfd_size_type nchains = 0;
11591   bfd_vma * buckets = NULL;
11592   bfd_vma * chains = NULL;
11593   bfd_vma ngnubuckets = 0;
11594   bfd_vma * gnubuckets = NULL;
11595   bfd_vma * gnuchains = NULL;
11596   bfd_vma gnusymidx = 0;
11597   bfd_size_type ngnuchains = 0;
11598
11599   if (!do_syms && !do_dyn_syms && !do_histogram)
11600     return TRUE;
11601
11602   if (dynamic_info[DT_HASH]
11603       && (do_histogram
11604           || (do_using_dynamic
11605               && !do_dyn_syms
11606               && dynamic_strings != NULL)))
11607     {
11608       unsigned char nb[8];
11609       unsigned char nc[8];
11610       unsigned int hash_ent_size = 4;
11611
11612       if ((filedata->file_header.e_machine == EM_ALPHA
11613            || filedata->file_header.e_machine == EM_S390
11614            || filedata->file_header.e_machine == EM_S390_OLD)
11615           && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11616         hash_ent_size = 8;
11617
11618       if (fseek (filedata->handle,
11619                  (archive_file_offset
11620                   + offset_from_vma (filedata, dynamic_info[DT_HASH],
11621                                      sizeof nb + sizeof nc)),
11622                  SEEK_SET))
11623         {
11624           error (_("Unable to seek to start of dynamic information\n"));
11625           goto no_hash;
11626         }
11627
11628       if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11629         {
11630           error (_("Failed to read in number of buckets\n"));
11631           goto no_hash;
11632         }
11633
11634       if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11635         {
11636           error (_("Failed to read in number of chains\n"));
11637           goto no_hash;
11638         }
11639
11640       nbuckets = byte_get (nb, hash_ent_size);
11641       nchains  = byte_get (nc, hash_ent_size);
11642
11643       buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11644       chains  = get_dynamic_data (filedata, nchains, hash_ent_size);
11645
11646     no_hash:
11647       if (buckets == NULL || chains == NULL)
11648         {
11649           if (do_using_dynamic)
11650             return FALSE;
11651           free (buckets);
11652           free (chains);
11653           buckets = NULL;
11654           chains = NULL;
11655           nbuckets = 0;
11656           nchains = 0;
11657         }
11658     }
11659
11660   if (dynamic_info_DT_GNU_HASH
11661       && (do_histogram
11662           || (do_using_dynamic
11663               && !do_dyn_syms
11664               && dynamic_strings != NULL)))
11665     {
11666       unsigned char nb[16];
11667       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11668       bfd_vma buckets_vma;
11669
11670       if (fseek (filedata->handle,
11671                  (archive_file_offset
11672                   + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11673                                      sizeof nb)),
11674                  SEEK_SET))
11675         {
11676           error (_("Unable to seek to start of dynamic information\n"));
11677           goto no_gnu_hash;
11678         }
11679
11680       if (fread (nb, 16, 1, filedata->handle) != 1)
11681         {
11682           error (_("Failed to read in number of buckets\n"));
11683           goto no_gnu_hash;
11684         }
11685
11686       ngnubuckets = byte_get (nb, 4);
11687       gnusymidx = byte_get (nb + 4, 4);
11688       bitmaskwords = byte_get (nb + 8, 4);
11689       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11690       if (is_32bit_elf)
11691         buckets_vma += bitmaskwords * 4;
11692       else
11693         buckets_vma += bitmaskwords * 8;
11694
11695       if (fseek (filedata->handle,
11696                  (archive_file_offset
11697                   + offset_from_vma (filedata, buckets_vma, 4)),
11698                  SEEK_SET))
11699         {
11700           error (_("Unable to seek to start of dynamic information\n"));
11701           goto no_gnu_hash;
11702         }
11703
11704       gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11705
11706       if (gnubuckets == NULL)
11707         goto no_gnu_hash;
11708
11709       for (i = 0; i < ngnubuckets; i++)
11710         if (gnubuckets[i] != 0)
11711           {
11712             if (gnubuckets[i] < gnusymidx)
11713               return FALSE;
11714
11715             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11716               maxchain = gnubuckets[i];
11717           }
11718
11719       if (maxchain == 0xffffffff)
11720         goto no_gnu_hash;
11721
11722       maxchain -= gnusymidx;
11723
11724       if (fseek (filedata->handle,
11725                  (archive_file_offset
11726                   + offset_from_vma (filedata, buckets_vma
11727                                            + 4 * (ngnubuckets + maxchain), 4)),
11728                  SEEK_SET))
11729         {
11730           error (_("Unable to seek to start of dynamic information\n"));
11731           goto no_gnu_hash;
11732         }
11733
11734       do
11735         {
11736           if (fread (nb, 4, 1, filedata->handle) != 1)
11737             {
11738               error (_("Failed to determine last chain length\n"));
11739               goto no_gnu_hash;
11740             }
11741
11742           if (maxchain + 1 == 0)
11743             goto no_gnu_hash;
11744
11745           ++maxchain;
11746         }
11747       while ((byte_get (nb, 4) & 1) == 0);
11748
11749       if (fseek (filedata->handle,
11750                  (archive_file_offset
11751                   + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11752                  SEEK_SET))
11753         {
11754           error (_("Unable to seek to start of dynamic information\n"));
11755           goto no_gnu_hash;
11756         }
11757
11758       gnuchains = get_dynamic_data (filedata, maxchain, 4);
11759       ngnuchains = maxchain;
11760
11761     no_gnu_hash:
11762       if (gnuchains == NULL)
11763         {
11764           free (gnubuckets);
11765           gnubuckets = NULL;
11766           ngnubuckets = 0;
11767           if (do_using_dynamic)
11768             return FALSE;
11769         }
11770     }
11771
11772   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11773       && do_syms
11774       && do_using_dynamic
11775       && dynamic_strings != NULL
11776       && dynamic_symbols != NULL)
11777     {
11778       unsigned long hn;
11779
11780       if (dynamic_info[DT_HASH])
11781         {
11782           bfd_vma si;
11783           char *visited;
11784
11785           printf (_("\nSymbol table for image:\n"));
11786           if (is_32bit_elf)
11787             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11788           else
11789             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11790
11791           visited = xcmalloc (nchains, 1);
11792           memset (visited, 0, nchains);
11793           for (hn = 0; hn < nbuckets; hn++)
11794             {
11795               for (si = buckets[hn]; si > 0; si = chains[si])
11796                 {
11797                   print_dynamic_symbol (filedata, si, hn);
11798                   if (si >= nchains || visited[si])
11799                     {
11800                       error (_("histogram chain is corrupt\n"));
11801                       break;
11802                     }
11803                   visited[si] = 1;
11804                 }
11805             }
11806           free (visited);
11807         }
11808
11809       if (dynamic_info_DT_GNU_HASH)
11810         {
11811           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11812           if (is_32bit_elf)
11813             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11814           else
11815             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11816
11817           for (hn = 0; hn < ngnubuckets; ++hn)
11818             if (gnubuckets[hn] != 0)
11819               {
11820                 bfd_vma si = gnubuckets[hn];
11821                 bfd_vma off = si - gnusymidx;
11822
11823                 do
11824                   {
11825                     print_dynamic_symbol (filedata, si, hn);
11826                     si++;
11827                   }
11828                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11829               }
11830         }
11831     }
11832   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11833            && filedata->section_headers != NULL)
11834     {
11835       unsigned int i;
11836
11837       for (i = 0, section = filedata->section_headers;
11838            i < filedata->file_header.e_shnum;
11839            i++, section++)
11840         {
11841           unsigned int si;
11842           char * strtab = NULL;
11843           unsigned long int strtab_size = 0;
11844           Elf_Internal_Sym * symtab;
11845           Elf_Internal_Sym * psym;
11846           unsigned long num_syms;
11847
11848           if ((section->sh_type != SHT_SYMTAB
11849                && section->sh_type != SHT_DYNSYM)
11850               || (!do_syms
11851                   && section->sh_type == SHT_SYMTAB))
11852             continue;
11853
11854           if (section->sh_entsize == 0)
11855             {
11856               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11857                       printable_section_name (filedata, section));
11858               continue;
11859             }
11860
11861           num_syms = section->sh_size / section->sh_entsize;
11862           printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11863                             "\nSymbol table '%s' contains %lu entries:\n",
11864                             num_syms),
11865                   printable_section_name (filedata, section),
11866                   num_syms);
11867
11868           if (is_32bit_elf)
11869             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
11870           else
11871             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
11872
11873           symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
11874           if (symtab == NULL)
11875             continue;
11876
11877           if (section->sh_link == filedata->file_header.e_shstrndx)
11878             {
11879               strtab = filedata->string_table;
11880               strtab_size = filedata->string_table_length;
11881             }
11882           else if (section->sh_link < filedata->file_header.e_shnum)
11883             {
11884               Elf_Internal_Shdr * string_sec;
11885
11886               string_sec = filedata->section_headers + section->sh_link;
11887
11888               strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
11889                                           1, string_sec->sh_size,
11890                                           _("string table"));
11891               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11892             }
11893
11894           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11895             {
11896               const char *version_string;
11897               enum versioned_symbol_info sym_info;
11898               unsigned short vna_other;
11899
11900               printf ("%6d: ", si);
11901               print_vma (psym->st_value, LONG_HEX);
11902               putchar (' ');
11903               print_vma (psym->st_size, DEC_5);
11904               printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11905               printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11906               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11907                 printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11908               else
11909                 {
11910                   unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11911
11912                   printf (" %-7s", get_symbol_visibility (vis));
11913                   /* Check to see if any other bits in the st_other field are set.
11914                      Note - displaying this information disrupts the layout of the
11915                      table being generated, but for the moment this case is very rare.  */
11916                   if (psym->st_other ^ vis)
11917                     printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11918                 }
11919               printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
11920               print_symbol (25, psym->st_name < strtab_size
11921                             ? strtab + psym->st_name : _("<corrupt>"));
11922
11923               version_string
11924                 = get_symbol_version_string (filedata,
11925                                              section->sh_type == SHT_DYNSYM,
11926                                              strtab, strtab_size, si,
11927                                              psym, &sym_info, &vna_other);
11928               if (version_string)
11929                 {
11930                   if (sym_info == symbol_undefined)
11931                     printf ("@%s (%d)", version_string, vna_other);
11932                   else
11933                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11934                             version_string);
11935                 }
11936
11937               putchar ('\n');
11938
11939               if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11940                   && si >= section->sh_info
11941                   /* Irix 5 and 6 MIPS binaries are known to ignore this requirement.  */
11942                   && filedata->file_header.e_machine != EM_MIPS
11943                   /* Solaris binaries have been found to violate this requirement as
11944                      well.  Not sure if this is a bug or an ABI requirement.  */
11945                   && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11946                 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11947                       si, printable_section_name (filedata, section), section->sh_info);
11948             }
11949
11950           free (symtab);
11951           if (strtab != filedata->string_table)
11952             free (strtab);
11953         }
11954     }
11955   else if (do_syms)
11956     printf
11957       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11958
11959   if (do_histogram && buckets != NULL)
11960     {
11961       unsigned long * lengths;
11962       unsigned long * counts;
11963       unsigned long hn;
11964       bfd_vma si;
11965       unsigned long maxlength = 0;
11966       unsigned long nzero_counts = 0;
11967       unsigned long nsyms = 0;
11968       char *visited;
11969
11970       printf (ngettext ("\nHistogram for bucket list length "
11971                         "(total of %lu bucket):\n",
11972                         "\nHistogram for bucket list length "
11973                         "(total of %lu buckets):\n",
11974                         (unsigned long) nbuckets),
11975               (unsigned long) nbuckets);
11976
11977       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11978       if (lengths == NULL)
11979         {
11980           error (_("Out of memory allocating space for histogram buckets\n"));
11981           return FALSE;
11982         }
11983       visited = xcmalloc (nchains, 1);
11984       memset (visited, 0, nchains);
11985
11986       printf (_(" Length  Number     %% of total  Coverage\n"));
11987       for (hn = 0; hn < nbuckets; ++hn)
11988         {
11989           for (si = buckets[hn]; si > 0; si = chains[si])
11990             {
11991               ++nsyms;
11992               if (maxlength < ++lengths[hn])
11993                 ++maxlength;
11994               if (si >= nchains || visited[si])
11995                 {
11996                   error (_("histogram chain is corrupt\n"));
11997                   break;
11998                 }
11999               visited[si] = 1;
12000             }
12001         }
12002       free (visited);
12003
12004       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
12005       if (counts == NULL)
12006         {
12007           free (lengths);
12008           error (_("Out of memory allocating space for histogram counts\n"));
12009           return FALSE;
12010         }
12011
12012       for (hn = 0; hn < nbuckets; ++hn)
12013         ++counts[lengths[hn]];
12014
12015       if (nbuckets > 0)
12016         {
12017           unsigned long i;
12018           printf ("      0  %-10lu (%5.1f%%)\n",
12019                   counts[0], (counts[0] * 100.0) / nbuckets);
12020           for (i = 1; i <= maxlength; ++i)
12021             {
12022               nzero_counts += counts[i] * i;
12023               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
12024                       i, counts[i], (counts[i] * 100.0) / nbuckets,
12025                       (nzero_counts * 100.0) / nsyms);
12026             }
12027         }
12028
12029       free (counts);
12030       free (lengths);
12031     }
12032
12033   if (buckets != NULL)
12034     {
12035       free (buckets);
12036       free (chains);
12037     }
12038
12039   if (do_histogram && gnubuckets != NULL)
12040     {
12041       unsigned long * lengths;
12042       unsigned long * counts;
12043       unsigned long hn;
12044       unsigned long maxlength = 0;
12045       unsigned long nzero_counts = 0;
12046       unsigned long nsyms = 0;
12047
12048       printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
12049                         "(total of %lu bucket):\n",
12050                         "\nHistogram for `.gnu.hash' bucket list length "
12051                         "(total of %lu buckets):\n",
12052                         (unsigned long) ngnubuckets),
12053               (unsigned long) ngnubuckets);
12054
12055       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
12056       if (lengths == NULL)
12057         {
12058           error (_("Out of memory allocating space for gnu histogram buckets\n"));
12059           return FALSE;
12060         }
12061
12062       printf (_(" Length  Number     %% of total  Coverage\n"));
12063
12064       for (hn = 0; hn < ngnubuckets; ++hn)
12065         if (gnubuckets[hn] != 0)
12066           {
12067             bfd_vma off, length = 1;
12068
12069             for (off = gnubuckets[hn] - gnusymidx;
12070                  /* PR 17531 file: 010-77222-0.004.  */
12071                  off < ngnuchains && (gnuchains[off] & 1) == 0;
12072                  ++off)
12073               ++length;
12074             lengths[hn] = length;
12075             if (length > maxlength)
12076               maxlength = length;
12077             nsyms += length;
12078           }
12079
12080       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
12081       if (counts == NULL)
12082         {
12083           free (lengths);
12084           error (_("Out of memory allocating space for gnu histogram counts\n"));
12085           return FALSE;
12086         }
12087
12088       for (hn = 0; hn < ngnubuckets; ++hn)
12089         ++counts[lengths[hn]];
12090
12091       if (ngnubuckets > 0)
12092         {
12093           unsigned long j;
12094           printf ("      0  %-10lu (%5.1f%%)\n",
12095                   counts[0], (counts[0] * 100.0) / ngnubuckets);
12096           for (j = 1; j <= maxlength; ++j)
12097             {
12098               nzero_counts += counts[j] * j;
12099               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
12100                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
12101                       (nzero_counts * 100.0) / nsyms);
12102             }
12103         }
12104
12105       free (counts);
12106       free (lengths);
12107       free (gnubuckets);
12108       free (gnuchains);
12109     }
12110
12111   return TRUE;
12112 }
12113
12114 static bfd_boolean
12115 process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
12116 {
12117   unsigned int i;
12118
12119   if (dynamic_syminfo == NULL
12120       || !do_dynamic)
12121     /* No syminfo, this is ok.  */
12122     return TRUE;
12123
12124   /* There better should be a dynamic symbol section.  */
12125   if (dynamic_symbols == NULL || dynamic_strings == NULL)
12126     return FALSE;
12127
12128   if (dynamic_addr)
12129     printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12130                       "contains %d entry:\n",
12131                       "\nDynamic info segment at offset 0x%lx "
12132                       "contains %d entries:\n",
12133                       dynamic_syminfo_nent),
12134             dynamic_syminfo_offset, dynamic_syminfo_nent);
12135
12136   printf (_(" Num: Name                           BoundTo     Flags\n"));
12137   for (i = 0; i < dynamic_syminfo_nent; ++i)
12138     {
12139       unsigned short int flags = dynamic_syminfo[i].si_flags;
12140
12141       printf ("%4d: ", i);
12142       if (i >= num_dynamic_syms)
12143         printf (_("<corrupt index>"));
12144       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
12145         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
12146       else
12147         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
12148       putchar (' ');
12149
12150       switch (dynamic_syminfo[i].si_boundto)
12151         {
12152         case SYMINFO_BT_SELF:
12153           fputs ("SELF       ", stdout);
12154           break;
12155         case SYMINFO_BT_PARENT:
12156           fputs ("PARENT     ", stdout);
12157           break;
12158         default:
12159           if (dynamic_syminfo[i].si_boundto > 0
12160               && dynamic_syminfo[i].si_boundto < dynamic_nent
12161               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
12162             {
12163               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
12164               putchar (' ' );
12165             }
12166           else
12167             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
12168           break;
12169         }
12170
12171       if (flags & SYMINFO_FLG_DIRECT)
12172         printf (" DIRECT");
12173       if (flags & SYMINFO_FLG_PASSTHRU)
12174         printf (" PASSTHRU");
12175       if (flags & SYMINFO_FLG_COPY)
12176         printf (" COPY");
12177       if (flags & SYMINFO_FLG_LAZYLOAD)
12178         printf (" LAZYLOAD");
12179
12180       puts ("");
12181     }
12182
12183   return TRUE;
12184 }
12185
12186 #define IN_RANGE(START,END,ADDR,OFF)            \
12187   (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12188
12189 /* Check to see if the given reloc needs to be handled in a target specific
12190    manner.  If so then process the reloc and return TRUE otherwise return
12191    FALSE.
12192
12193    If called with reloc == NULL, then this is a signal that reloc processing
12194    for the current section has finished, and any saved state should be
12195    discarded.  */
12196
12197 static bfd_boolean
12198 target_specific_reloc_handling (Filedata *           filedata,
12199                                 Elf_Internal_Rela *  reloc,
12200                                 unsigned char *      start,
12201                                 unsigned char *      end,
12202                                 Elf_Internal_Sym *   symtab,
12203                                 unsigned long        num_syms)
12204 {
12205   unsigned int reloc_type = 0;
12206   unsigned long sym_index = 0;
12207
12208   if (reloc)
12209     {
12210       reloc_type = get_reloc_type (filedata, reloc->r_info);
12211       sym_index = get_reloc_symindex (reloc->r_info);
12212     }
12213
12214   switch (filedata->file_header.e_machine)
12215     {
12216     case EM_MSP430:
12217     case EM_MSP430_OLD:
12218       {
12219         static Elf_Internal_Sym * saved_sym = NULL;
12220
12221         if (reloc == NULL)
12222           {
12223             saved_sym = NULL;
12224             return TRUE;
12225           }
12226
12227         switch (reloc_type)
12228           {
12229           case 10: /* R_MSP430_SYM_DIFF */
12230             if (uses_msp430x_relocs (filedata))
12231               break;
12232             /* Fall through.  */
12233           case 21: /* R_MSP430X_SYM_DIFF */
12234             /* PR 21139.  */
12235             if (sym_index >= num_syms)
12236               error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12237                      sym_index);
12238             else
12239               saved_sym = symtab + sym_index;
12240             return TRUE;
12241
12242           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12243           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12244             goto handle_sym_diff;
12245
12246           case 5: /* R_MSP430_16_BYTE */
12247           case 9: /* R_MSP430_8 */
12248             if (uses_msp430x_relocs (filedata))
12249               break;
12250             goto handle_sym_diff;
12251
12252           case 2: /* R_MSP430_ABS16 */
12253           case 15: /* R_MSP430X_ABS16 */
12254             if (! uses_msp430x_relocs (filedata))
12255               break;
12256             goto handle_sym_diff;
12257
12258           handle_sym_diff:
12259             if (saved_sym != NULL)
12260               {
12261                 int reloc_size = reloc_type == 1 ? 4 : 2;
12262                 bfd_vma value;
12263
12264                 if (sym_index >= num_syms)
12265                   error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12266                          sym_index);
12267                 else
12268                   {
12269                     value = reloc->r_addend + (symtab[sym_index].st_value
12270                                                - saved_sym->st_value);
12271
12272                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12273                       byte_put (start + reloc->r_offset, value, reloc_size);
12274                     else
12275                       /* PR 21137 */
12276                       error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12277                              (long) reloc->r_offset);
12278                   }
12279
12280                 saved_sym = NULL;
12281                 return TRUE;
12282               }
12283             break;
12284
12285           default:
12286             if (saved_sym != NULL)
12287               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12288             break;
12289           }
12290         break;
12291       }
12292
12293     case EM_MN10300:
12294     case EM_CYGNUS_MN10300:
12295       {
12296         static Elf_Internal_Sym * saved_sym = NULL;
12297
12298         if (reloc == NULL)
12299           {
12300             saved_sym = NULL;
12301             return TRUE;
12302           }
12303
12304         switch (reloc_type)
12305           {
12306           case 34: /* R_MN10300_ALIGN */
12307             return TRUE;
12308           case 33: /* R_MN10300_SYM_DIFF */
12309             if (sym_index >= num_syms)
12310               error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12311                      sym_index);
12312             else
12313               saved_sym = symtab + sym_index;
12314             return TRUE;
12315
12316           case 1: /* R_MN10300_32 */
12317           case 2: /* R_MN10300_16 */
12318             if (saved_sym != NULL)
12319               {
12320                 int reloc_size = reloc_type == 1 ? 4 : 2;
12321                 bfd_vma value;
12322
12323                 if (sym_index >= num_syms)
12324                   error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12325                          sym_index);
12326                 else
12327                   {
12328                     value = reloc->r_addend + (symtab[sym_index].st_value
12329                                                - saved_sym->st_value);
12330
12331                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12332                       byte_put (start + reloc->r_offset, value, reloc_size);
12333                     else
12334                       error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12335                              (long) reloc->r_offset);
12336                   }
12337
12338                 saved_sym = NULL;
12339                 return TRUE;
12340               }
12341             break;
12342           default:
12343             if (saved_sym != NULL)
12344               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12345             break;
12346           }
12347         break;
12348       }
12349
12350     case EM_RL78:
12351       {
12352         static bfd_vma saved_sym1 = 0;
12353         static bfd_vma saved_sym2 = 0;
12354         static bfd_vma value;
12355
12356         if (reloc == NULL)
12357           {
12358             saved_sym1 = saved_sym2 = 0;
12359             return TRUE;
12360           }
12361
12362         switch (reloc_type)
12363           {
12364           case 0x80: /* R_RL78_SYM.  */
12365             saved_sym1 = saved_sym2;
12366             if (sym_index >= num_syms)
12367               error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12368                      sym_index);
12369             else
12370               {
12371                 saved_sym2 = symtab[sym_index].st_value;
12372                 saved_sym2 += reloc->r_addend;
12373               }
12374             return TRUE;
12375
12376           case 0x83: /* R_RL78_OPsub.  */
12377             value = saved_sym1 - saved_sym2;
12378             saved_sym2 = saved_sym1 = 0;
12379             return TRUE;
12380             break;
12381
12382           case 0x41: /* R_RL78_ABS32.  */
12383             if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12384               byte_put (start + reloc->r_offset, value, 4);
12385             else
12386               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12387                      (long) reloc->r_offset);
12388             value = 0;
12389             return TRUE;
12390
12391           case 0x43: /* R_RL78_ABS16.  */
12392             if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12393               byte_put (start + reloc->r_offset, value, 2);
12394             else
12395               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12396                      (long) reloc->r_offset);
12397             value = 0;
12398             return TRUE;
12399
12400           default:
12401             break;
12402           }
12403         break;
12404       }
12405     }
12406
12407   return FALSE;
12408 }
12409
12410 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12411    DWARF debug sections.  This is a target specific test.  Note - we do not
12412    go through the whole including-target-headers-multiple-times route, (as
12413    we have already done with <elf/h8.h>) because this would become very
12414    messy and even then this function would have to contain target specific
12415    information (the names of the relocs instead of their numeric values).
12416    FIXME: This is not the correct way to solve this problem.  The proper way
12417    is to have target specific reloc sizing and typing functions created by
12418    the reloc-macros.h header, in the same way that it already creates the
12419    reloc naming functions.  */
12420
12421 static bfd_boolean
12422 is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12423 {
12424   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12425   switch (filedata->file_header.e_machine)
12426     {
12427     case EM_386:
12428     case EM_IAMCU:
12429       return reloc_type == 1; /* R_386_32.  */
12430     case EM_68K:
12431       return reloc_type == 1; /* R_68K_32.  */
12432     case EM_860:
12433       return reloc_type == 1; /* R_860_32.  */
12434     case EM_960:
12435       return reloc_type == 2; /* R_960_32.  */
12436     case EM_AARCH64:
12437       return (reloc_type == 258
12438               || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12439     case EM_BPF:
12440       return reloc_type == 11; /* R_BPF_DATA_32 */
12441     case EM_ADAPTEVA_EPIPHANY:
12442       return reloc_type == 3;
12443     case EM_ALPHA:
12444       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
12445     case EM_ARC:
12446       return reloc_type == 1; /* R_ARC_32.  */
12447     case EM_ARC_COMPACT:
12448     case EM_ARC_COMPACT2:
12449       return reloc_type == 4; /* R_ARC_32.  */
12450     case EM_ARM:
12451       return reloc_type == 2; /* R_ARM_ABS32 */
12452     case EM_AVR_OLD:
12453     case EM_AVR:
12454       return reloc_type == 1;
12455     case EM_BLACKFIN:
12456       return reloc_type == 0x12; /* R_byte4_data.  */
12457     case EM_CRIS:
12458       return reloc_type == 3; /* R_CRIS_32.  */
12459     case EM_CR16:
12460       return reloc_type == 3; /* R_CR16_NUM32.  */
12461     case EM_CRX:
12462       return reloc_type == 15; /* R_CRX_NUM32.  */
12463     case EM_CSKY:
12464       return reloc_type == 1; /* R_CKCORE_ADDR32.  */
12465     case EM_CYGNUS_FRV:
12466       return reloc_type == 1;
12467     case EM_CYGNUS_D10V:
12468     case EM_D10V:
12469       return reloc_type == 6; /* R_D10V_32.  */
12470     case EM_CYGNUS_D30V:
12471     case EM_D30V:
12472       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
12473     case EM_DLX:
12474       return reloc_type == 3; /* R_DLX_RELOC_32.  */
12475     case EM_CYGNUS_FR30:
12476     case EM_FR30:
12477       return reloc_type == 3; /* R_FR30_32.  */
12478     case EM_FT32:
12479       return reloc_type == 1; /* R_FT32_32.  */
12480     case EM_H8S:
12481     case EM_H8_300:
12482     case EM_H8_300H:
12483       return reloc_type == 1; /* R_H8_DIR32.  */
12484     case EM_IA_64:
12485       return (reloc_type == 0x64    /* R_IA64_SECREL32MSB.  */
12486               || reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
12487               || reloc_type == 0x24 /* R_IA64_DIR32MSB.  */
12488               || reloc_type == 0x25 /* R_IA64_DIR32LSB.  */);
12489     case EM_IP2K_OLD:
12490     case EM_IP2K:
12491       return reloc_type == 2; /* R_IP2K_32.  */
12492     case EM_IQ2000:
12493       return reloc_type == 2; /* R_IQ2000_32.  */
12494     case EM_LATTICEMICO32:
12495       return reloc_type == 3; /* R_LM32_32.  */
12496     case EM_M32C_OLD:
12497     case EM_M32C:
12498       return reloc_type == 3; /* R_M32C_32.  */
12499     case EM_M32R:
12500       return reloc_type == 34; /* R_M32R_32_RELA.  */
12501     case EM_68HC11:
12502     case EM_68HC12:
12503       return reloc_type == 6; /* R_M68HC11_32.  */
12504     case EM_S12Z:
12505       return reloc_type == 7 || /* R_S12Z_EXT32 */
12506         reloc_type == 6;        /* R_S12Z_CW32.  */
12507     case EM_MCORE:
12508       return reloc_type == 1; /* R_MCORE_ADDR32.  */
12509     case EM_CYGNUS_MEP:
12510       return reloc_type == 4; /* R_MEP_32.  */
12511     case EM_METAG:
12512       return reloc_type == 2; /* R_METAG_ADDR32.  */
12513     case EM_MICROBLAZE:
12514       return reloc_type == 1; /* R_MICROBLAZE_32.  */
12515     case EM_MIPS:
12516       return reloc_type == 2; /* R_MIPS_32.  */
12517     case EM_MMIX:
12518       return reloc_type == 4; /* R_MMIX_32.  */
12519     case EM_CYGNUS_MN10200:
12520     case EM_MN10200:
12521       return reloc_type == 1; /* R_MN10200_32.  */
12522     case EM_CYGNUS_MN10300:
12523     case EM_MN10300:
12524       return reloc_type == 1; /* R_MN10300_32.  */
12525     case EM_MOXIE:
12526       return reloc_type == 1; /* R_MOXIE_32.  */
12527     case EM_MSP430_OLD:
12528     case EM_MSP430:
12529       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
12530     case EM_MT:
12531       return reloc_type == 2; /* R_MT_32.  */
12532     case EM_NDS32:
12533       return reloc_type == 20; /* R_NDS32_RELA.  */
12534     case EM_ALTERA_NIOS2:
12535       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
12536     case EM_NIOS32:
12537       return reloc_type == 1; /* R_NIOS_32.  */
12538     case EM_OR1K:
12539       return reloc_type == 1; /* R_OR1K_32.  */
12540     case EM_PARISC:
12541       return (reloc_type == 1 /* R_PARISC_DIR32.  */
12542               || reloc_type == 2 /* R_PARISC_DIR21L.  */
12543               || reloc_type == 41); /* R_PARISC_SECREL32.  */
12544     case EM_PJ:
12545     case EM_PJ_OLD:
12546       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
12547     case EM_PPC64:
12548       return reloc_type == 1; /* R_PPC64_ADDR32.  */
12549     case EM_PPC:
12550       return reloc_type == 1; /* R_PPC_ADDR32.  */
12551     case EM_TI_PRU:
12552       return reloc_type == 11; /* R_PRU_BFD_RELOC_32.  */
12553     case EM_RISCV:
12554       return reloc_type == 1; /* R_RISCV_32.  */
12555     case EM_RL78:
12556       return reloc_type == 1; /* R_RL78_DIR32.  */
12557     case EM_RX:
12558       return reloc_type == 1; /* R_RX_DIR32.  */
12559     case EM_S370:
12560       return reloc_type == 1; /* R_I370_ADDR31.  */
12561     case EM_S390_OLD:
12562     case EM_S390:
12563       return reloc_type == 4; /* R_S390_32.  */
12564     case EM_SCORE:
12565       return reloc_type == 8; /* R_SCORE_ABS32.  */
12566     case EM_SH:
12567       return reloc_type == 1; /* R_SH_DIR32.  */
12568     case EM_SPARC32PLUS:
12569     case EM_SPARCV9:
12570     case EM_SPARC:
12571       return reloc_type == 3 /* R_SPARC_32.  */
12572         || reloc_type == 23; /* R_SPARC_UA32.  */
12573     case EM_SPU:
12574       return reloc_type == 6; /* R_SPU_ADDR32 */
12575     case EM_TI_C6000:
12576       return reloc_type == 1; /* R_C6000_ABS32.  */
12577     case EM_TILEGX:
12578       return reloc_type == 2; /* R_TILEGX_32.  */
12579     case EM_TILEPRO:
12580       return reloc_type == 1; /* R_TILEPRO_32.  */
12581     case EM_CYGNUS_V850:
12582     case EM_V850:
12583       return reloc_type == 6; /* R_V850_ABS32.  */
12584     case EM_V800:
12585       return reloc_type == 0x33; /* R_V810_WORD.  */
12586     case EM_VAX:
12587       return reloc_type == 1; /* R_VAX_32.  */
12588     case EM_VISIUM:
12589       return reloc_type == 3;  /* R_VISIUM_32. */
12590     case EM_WEBASSEMBLY:
12591       return reloc_type == 1;  /* R_WASM32_32.  */
12592     case EM_X86_64:
12593     case EM_L1OM:
12594     case EM_K1OM:
12595       return reloc_type == 10; /* R_X86_64_32.  */
12596     case EM_XC16X:
12597     case EM_C166:
12598       return reloc_type == 3; /* R_XC16C_ABS_32.  */
12599     case EM_XGATE:
12600       return reloc_type == 4; /* R_XGATE_32.  */
12601     case EM_XSTORMY16:
12602       return reloc_type == 1; /* R_XSTROMY16_32.  */
12603     case EM_XTENSA_OLD:
12604     case EM_XTENSA:
12605       return reloc_type == 1; /* R_XTENSA_32.  */
12606     default:
12607       {
12608         static unsigned int prev_warn = 0;
12609
12610         /* Avoid repeating the same warning multiple times.  */
12611         if (prev_warn != filedata->file_header.e_machine)
12612           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12613                  filedata->file_header.e_machine);
12614         prev_warn = filedata->file_header.e_machine;
12615         return FALSE;
12616       }
12617     }
12618 }
12619
12620 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12621    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
12622
12623 static bfd_boolean
12624 is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12625 {
12626   switch (filedata->file_header.e_machine)
12627   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12628     {
12629     case EM_386:
12630     case EM_IAMCU:
12631       return reloc_type == 2;  /* R_386_PC32.  */
12632     case EM_68K:
12633       return reloc_type == 4;  /* R_68K_PC32.  */
12634     case EM_AARCH64:
12635       return reloc_type == 261; /* R_AARCH64_PREL32 */
12636     case EM_ADAPTEVA_EPIPHANY:
12637       return reloc_type == 6;
12638     case EM_ALPHA:
12639       return reloc_type == 10; /* R_ALPHA_SREL32.  */
12640     case EM_ARC_COMPACT:
12641     case EM_ARC_COMPACT2:
12642       return reloc_type == 49; /* R_ARC_32_PCREL.  */
12643     case EM_ARM:
12644       return reloc_type == 3;  /* R_ARM_REL32 */
12645     case EM_AVR_OLD:
12646     case EM_AVR:
12647       return reloc_type == 36; /* R_AVR_32_PCREL.  */
12648     case EM_MICROBLAZE:
12649       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
12650     case EM_OR1K:
12651       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
12652     case EM_PARISC:
12653       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
12654     case EM_PPC:
12655       return reloc_type == 26; /* R_PPC_REL32.  */
12656     case EM_PPC64:
12657       return reloc_type == 26; /* R_PPC64_REL32.  */
12658     case EM_RISCV:
12659       return reloc_type == 57;  /* R_RISCV_32_PCREL.  */
12660     case EM_S390_OLD:
12661     case EM_S390:
12662       return reloc_type == 5;  /* R_390_PC32.  */
12663     case EM_SH:
12664       return reloc_type == 2;  /* R_SH_REL32.  */
12665     case EM_SPARC32PLUS:
12666     case EM_SPARCV9:
12667     case EM_SPARC:
12668       return reloc_type == 6;  /* R_SPARC_DISP32.  */
12669     case EM_SPU:
12670       return reloc_type == 13; /* R_SPU_REL32.  */
12671     case EM_TILEGX:
12672       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
12673     case EM_TILEPRO:
12674       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
12675     case EM_VISIUM:
12676       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
12677     case EM_X86_64:
12678     case EM_L1OM:
12679     case EM_K1OM:
12680       return reloc_type == 2;  /* R_X86_64_PC32.  */
12681     case EM_XTENSA_OLD:
12682     case EM_XTENSA:
12683       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
12684     default:
12685       /* Do not abort or issue an error message here.  Not all targets use
12686          pc-relative 32-bit relocs in their DWARF debug information and we
12687          have already tested for target coverage in is_32bit_abs_reloc.  A
12688          more helpful warning message will be generated by apply_relocations
12689          anyway, so just return.  */
12690       return FALSE;
12691     }
12692 }
12693
12694 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12695    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
12696
12697 static bfd_boolean
12698 is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12699 {
12700   switch (filedata->file_header.e_machine)
12701     {
12702     case EM_AARCH64:
12703       return reloc_type == 257; /* R_AARCH64_ABS64.  */
12704     case EM_ALPHA:
12705       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
12706     case EM_IA_64:
12707       return (reloc_type == 0x26    /* R_IA64_DIR64MSB.  */
12708               || reloc_type == 0x27 /* R_IA64_DIR64LSB.  */);
12709     case EM_PARISC:
12710       return reloc_type == 80; /* R_PARISC_DIR64.  */
12711     case EM_PPC64:
12712       return reloc_type == 38; /* R_PPC64_ADDR64.  */
12713     case EM_RISCV:
12714       return reloc_type == 2; /* R_RISCV_64.  */
12715     case EM_SPARC32PLUS:
12716     case EM_SPARCV9:
12717     case EM_SPARC:
12718       return reloc_type == 32 /* R_SPARC_64.  */
12719         || reloc_type == 54; /* R_SPARC_UA64.  */
12720     case EM_X86_64:
12721     case EM_L1OM:
12722     case EM_K1OM:
12723       return reloc_type == 1; /* R_X86_64_64.  */
12724     case EM_S390_OLD:
12725     case EM_S390:
12726       return reloc_type == 22;  /* R_S390_64.  */
12727     case EM_TILEGX:
12728       return reloc_type == 1; /* R_TILEGX_64.  */
12729     case EM_MIPS:
12730       return reloc_type == 18;  /* R_MIPS_64.  */
12731     default:
12732       return FALSE;
12733     }
12734 }
12735
12736 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12737    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
12738
12739 static bfd_boolean
12740 is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12741 {
12742   switch (filedata->file_header.e_machine)
12743     {
12744     case EM_AARCH64:
12745       return reloc_type == 260; /* R_AARCH64_PREL64.  */
12746     case EM_ALPHA:
12747       return reloc_type == 11; /* R_ALPHA_SREL64.  */
12748     case EM_IA_64:
12749       return (reloc_type == 0x4e    /* R_IA64_PCREL64MSB.  */
12750               || reloc_type == 0x4f /* R_IA64_PCREL64LSB.  */);
12751     case EM_PARISC:
12752       return reloc_type == 72; /* R_PARISC_PCREL64.  */
12753     case EM_PPC64:
12754       return reloc_type == 44; /* R_PPC64_REL64.  */
12755     case EM_SPARC32PLUS:
12756     case EM_SPARCV9:
12757     case EM_SPARC:
12758       return reloc_type == 46; /* R_SPARC_DISP64.  */
12759     case EM_X86_64:
12760     case EM_L1OM:
12761     case EM_K1OM:
12762       return reloc_type == 24; /* R_X86_64_PC64.  */
12763     case EM_S390_OLD:
12764     case EM_S390:
12765       return reloc_type == 23;  /* R_S390_PC64.  */
12766     case EM_TILEGX:
12767       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
12768     default:
12769       return FALSE;
12770     }
12771 }
12772
12773 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12774    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
12775
12776 static bfd_boolean
12777 is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12778 {
12779   switch (filedata->file_header.e_machine)
12780     {
12781     case EM_CYGNUS_MN10200:
12782     case EM_MN10200:
12783       return reloc_type == 4; /* R_MN10200_24.  */
12784     case EM_FT32:
12785       return reloc_type == 5; /* R_FT32_20.  */
12786     default:
12787       return FALSE;
12788     }
12789 }
12790
12791 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12792    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
12793
12794 static bfd_boolean
12795 is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12796 {
12797   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12798   switch (filedata->file_header.e_machine)
12799     {
12800     case EM_ARC:
12801     case EM_ARC_COMPACT:
12802     case EM_ARC_COMPACT2:
12803       return reloc_type == 2; /* R_ARC_16.  */
12804     case EM_ADAPTEVA_EPIPHANY:
12805       return reloc_type == 5;
12806     case EM_AVR_OLD:
12807     case EM_AVR:
12808       return reloc_type == 4; /* R_AVR_16.  */
12809     case EM_CYGNUS_D10V:
12810     case EM_D10V:
12811       return reloc_type == 3; /* R_D10V_16.  */
12812     case EM_FT32:
12813       return reloc_type == 2; /* R_FT32_16.  */
12814     case EM_H8S:
12815     case EM_H8_300:
12816     case EM_H8_300H:
12817       return reloc_type == R_H8_DIR16;
12818     case EM_IP2K_OLD:
12819     case EM_IP2K:
12820       return reloc_type == 1; /* R_IP2K_16.  */
12821     case EM_M32C_OLD:
12822     case EM_M32C:
12823       return reloc_type == 1; /* R_M32C_16 */
12824     case EM_CYGNUS_MN10200:
12825     case EM_MN10200:
12826       return reloc_type == 2; /* R_MN10200_16.  */
12827     case EM_CYGNUS_MN10300:
12828     case EM_MN10300:
12829       return reloc_type == 2; /* R_MN10300_16.  */
12830     case EM_MSP430:
12831       if (uses_msp430x_relocs (filedata))
12832         return reloc_type == 2; /* R_MSP430_ABS16.  */
12833       /* Fall through.  */
12834     case EM_MSP430_OLD:
12835       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
12836     case EM_NDS32:
12837       return reloc_type == 19; /* R_NDS32_RELA.  */
12838     case EM_ALTERA_NIOS2:
12839       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
12840     case EM_NIOS32:
12841       return reloc_type == 9; /* R_NIOS_16.  */
12842     case EM_OR1K:
12843       return reloc_type == 2; /* R_OR1K_16.  */
12844     case EM_RISCV:
12845       return reloc_type == 55; /* R_RISCV_SET16.  */
12846     case EM_TI_PRU:
12847       return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
12848     case EM_TI_C6000:
12849       return reloc_type == 2; /* R_C6000_ABS16.  */
12850     case EM_VISIUM:
12851       return reloc_type == 2; /* R_VISIUM_16. */
12852     case EM_XC16X:
12853     case EM_C166:
12854       return reloc_type == 2; /* R_XC16C_ABS_16.  */
12855     case EM_XGATE:
12856       return reloc_type == 3; /* R_XGATE_16.  */
12857     default:
12858       return FALSE;
12859     }
12860 }
12861
12862 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12863    a 8-bit absolute RELA relocation used in DWARF debug sections.  */
12864
12865 static bfd_boolean
12866 is_8bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12867 {
12868   switch (filedata->file_header.e_machine)
12869     {
12870     case EM_RISCV:
12871       return reloc_type == 54; /* R_RISCV_SET8.  */
12872     default:
12873       return FALSE;
12874     }
12875 }
12876
12877 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12878    a 6-bit absolute RELA relocation used in DWARF debug sections.  */
12879
12880 static bfd_boolean
12881 is_6bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12882 {
12883   switch (filedata->file_header.e_machine)
12884     {
12885     case EM_RISCV:
12886       return reloc_type == 53; /* R_RISCV_SET6.  */
12887     default:
12888       return FALSE;
12889     }
12890 }
12891
12892 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12893    a 32-bit inplace add RELA relocation used in DWARF debug sections.  */
12894
12895 static bfd_boolean
12896 is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12897 {
12898   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12899   switch (filedata->file_header.e_machine)
12900     {
12901     case EM_RISCV:
12902       return reloc_type == 35; /* R_RISCV_ADD32.  */
12903     default:
12904       return FALSE;
12905     }
12906 }
12907
12908 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12909    a 32-bit inplace sub RELA relocation used in DWARF debug sections.  */
12910
12911 static bfd_boolean
12912 is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12913 {
12914   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12915   switch (filedata->file_header.e_machine)
12916     {
12917     case EM_RISCV:
12918       return reloc_type == 39; /* R_RISCV_SUB32.  */
12919     default:
12920       return FALSE;
12921     }
12922 }
12923
12924 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12925    a 64-bit inplace add RELA relocation used in DWARF debug sections.  */
12926
12927 static bfd_boolean
12928 is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12929 {
12930   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12931   switch (filedata->file_header.e_machine)
12932     {
12933     case EM_RISCV:
12934       return reloc_type == 36; /* R_RISCV_ADD64.  */
12935     default:
12936       return FALSE;
12937     }
12938 }
12939
12940 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12941    a 64-bit inplace sub RELA relocation used in DWARF debug sections.  */
12942
12943 static bfd_boolean
12944 is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12945 {
12946   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12947   switch (filedata->file_header.e_machine)
12948     {
12949     case EM_RISCV:
12950       return reloc_type == 40; /* R_RISCV_SUB64.  */
12951     default:
12952       return FALSE;
12953     }
12954 }
12955
12956 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12957    a 16-bit inplace add RELA relocation used in DWARF debug sections.  */
12958
12959 static bfd_boolean
12960 is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12961 {
12962   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12963   switch (filedata->file_header.e_machine)
12964     {
12965     case EM_RISCV:
12966       return reloc_type == 34; /* R_RISCV_ADD16.  */
12967     default:
12968       return FALSE;
12969     }
12970 }
12971
12972 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12973    a 16-bit inplace sub RELA relocation used in DWARF debug sections.  */
12974
12975 static bfd_boolean
12976 is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12977 {
12978   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12979   switch (filedata->file_header.e_machine)
12980     {
12981     case EM_RISCV:
12982       return reloc_type == 38; /* R_RISCV_SUB16.  */
12983     default:
12984       return FALSE;
12985     }
12986 }
12987
12988 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12989    a 8-bit inplace add RELA relocation used in DWARF debug sections.  */
12990
12991 static bfd_boolean
12992 is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12993 {
12994   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12995   switch (filedata->file_header.e_machine)
12996     {
12997     case EM_RISCV:
12998       return reloc_type == 33; /* R_RISCV_ADD8.  */
12999     default:
13000       return FALSE;
13001     }
13002 }
13003
13004 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13005    a 8-bit inplace sub RELA relocation used in DWARF debug sections.  */
13006
13007 static bfd_boolean
13008 is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13009 {
13010   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13011   switch (filedata->file_header.e_machine)
13012     {
13013     case EM_RISCV:
13014       return reloc_type == 37; /* R_RISCV_SUB8.  */
13015     default:
13016       return FALSE;
13017     }
13018 }
13019
13020 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13021    a 6-bit inplace sub RELA relocation used in DWARF debug sections.  */
13022
13023 static bfd_boolean
13024 is_6bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13025 {
13026   switch (filedata->file_header.e_machine)
13027     {
13028     case EM_RISCV:
13029       return reloc_type == 52; /* R_RISCV_SUB6.  */
13030     default:
13031       return FALSE;
13032     }
13033 }
13034
13035 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13036    relocation entries (possibly formerly used for SHT_GROUP sections).  */
13037
13038 static bfd_boolean
13039 is_none_reloc (Filedata * filedata, unsigned int reloc_type)
13040 {
13041   switch (filedata->file_header.e_machine)
13042     {
13043     case EM_386:     /* R_386_NONE.  */
13044     case EM_68K:     /* R_68K_NONE.  */
13045     case EM_ADAPTEVA_EPIPHANY:
13046     case EM_ALPHA:   /* R_ALPHA_NONE.  */
13047     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
13048     case EM_ARC:     /* R_ARC_NONE.  */
13049     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
13050     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
13051     case EM_ARM:     /* R_ARM_NONE.  */
13052     case EM_C166:    /* R_XC16X_NONE.  */
13053     case EM_CRIS:    /* R_CRIS_NONE.  */
13054     case EM_FT32:    /* R_FT32_NONE.  */
13055     case EM_IA_64:   /* R_IA64_NONE.  */
13056     case EM_K1OM:    /* R_X86_64_NONE.  */
13057     case EM_L1OM:    /* R_X86_64_NONE.  */
13058     case EM_M32R:    /* R_M32R_NONE.  */
13059     case EM_MIPS:    /* R_MIPS_NONE.  */
13060     case EM_MN10300: /* R_MN10300_NONE.  */
13061     case EM_MOXIE:   /* R_MOXIE_NONE.  */
13062     case EM_NIOS32:  /* R_NIOS_NONE.  */
13063     case EM_OR1K:    /* R_OR1K_NONE. */
13064     case EM_PARISC:  /* R_PARISC_NONE.  */
13065     case EM_PPC64:   /* R_PPC64_NONE.  */
13066     case EM_PPC:     /* R_PPC_NONE.  */
13067     case EM_RISCV:   /* R_RISCV_NONE.  */
13068     case EM_S390:    /* R_390_NONE.  */
13069     case EM_S390_OLD:
13070     case EM_SH:      /* R_SH_NONE.  */
13071     case EM_SPARC32PLUS:
13072     case EM_SPARC:   /* R_SPARC_NONE.  */
13073     case EM_SPARCV9:
13074     case EM_TILEGX:  /* R_TILEGX_NONE.  */
13075     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
13076     case EM_TI_C6000:/* R_C6000_NONE.  */
13077     case EM_X86_64:  /* R_X86_64_NONE.  */
13078     case EM_XC16X:
13079     case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
13080       return reloc_type == 0;
13081
13082     case EM_AARCH64:
13083       return reloc_type == 0 || reloc_type == 256;
13084     case EM_AVR_OLD:
13085     case EM_AVR:
13086       return (reloc_type == 0 /* R_AVR_NONE.  */
13087               || reloc_type == 30 /* R_AVR_DIFF8.  */
13088               || reloc_type == 31 /* R_AVR_DIFF16.  */
13089               || reloc_type == 32 /* R_AVR_DIFF32.  */);
13090     case EM_METAG:
13091       return reloc_type == 3; /* R_METAG_NONE.  */
13092     case EM_NDS32:
13093       return (reloc_type == 0       /* R_XTENSA_NONE.  */
13094               || reloc_type == 204  /* R_NDS32_DIFF8.  */
13095               || reloc_type == 205  /* R_NDS32_DIFF16.  */
13096               || reloc_type == 206  /* R_NDS32_DIFF32.  */
13097               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
13098     case EM_TI_PRU:
13099       return (reloc_type == 0       /* R_PRU_NONE.  */
13100               || reloc_type == 65   /* R_PRU_DIFF8.  */
13101               || reloc_type == 66   /* R_PRU_DIFF16.  */
13102               || reloc_type == 67   /* R_PRU_DIFF32.  */);
13103     case EM_XTENSA_OLD:
13104     case EM_XTENSA:
13105       return (reloc_type == 0      /* R_XTENSA_NONE.  */
13106               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
13107               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
13108               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
13109     }
13110   return FALSE;
13111 }
13112
13113 /* Returns TRUE if there is a relocation against
13114    section NAME at OFFSET bytes.  */
13115
13116 bfd_boolean
13117 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
13118 {
13119   Elf_Internal_Rela * relocs;
13120   Elf_Internal_Rela * rp;
13121
13122   if (dsec == NULL || dsec->reloc_info == NULL)
13123     return FALSE;
13124
13125   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
13126
13127   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
13128     if (rp->r_offset == offset)
13129       return TRUE;
13130
13131    return FALSE;
13132 }
13133
13134 /* Apply relocations to a section.
13135    Returns TRUE upon success, FALSE otherwise.
13136    If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13137    It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
13138    will be set to the number of relocs loaded.
13139
13140    Note: So far support has been added only for those relocations
13141    which can be found in debug sections. FIXME: Add support for
13142    more relocations ?  */
13143
13144 static bfd_boolean
13145 apply_relocations (Filedata *                 filedata,
13146                    const Elf_Internal_Shdr *  section,
13147                    unsigned char *            start,
13148                    bfd_size_type              size,
13149                    void **                    relocs_return,
13150                    unsigned long *            num_relocs_return)
13151 {
13152   Elf_Internal_Shdr * relsec;
13153   unsigned char * end = start + size;
13154
13155   if (relocs_return != NULL)
13156     {
13157       * (Elf_Internal_Rela **) relocs_return = NULL;
13158       * num_relocs_return = 0;
13159     }
13160
13161   if (filedata->file_header.e_type != ET_REL)
13162     /* No relocs to apply.  */
13163     return TRUE;
13164
13165   /* Find the reloc section associated with the section.  */
13166   for (relsec = filedata->section_headers;
13167        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13168        ++relsec)
13169     {
13170       bfd_boolean is_rela;
13171       unsigned long num_relocs;
13172       Elf_Internal_Rela * relocs;
13173       Elf_Internal_Rela * rp;
13174       Elf_Internal_Shdr * symsec;
13175       Elf_Internal_Sym * symtab;
13176       unsigned long num_syms;
13177       Elf_Internal_Sym * sym;
13178
13179       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13180           || relsec->sh_info >= filedata->file_header.e_shnum
13181           || filedata->section_headers + relsec->sh_info != section
13182           || relsec->sh_size == 0
13183           || relsec->sh_link >= filedata->file_header.e_shnum)
13184         continue;
13185
13186       is_rela = relsec->sh_type == SHT_RELA;
13187
13188       if (is_rela)
13189         {
13190           if (!slurp_rela_relocs (filedata, relsec->sh_offset,
13191                                   relsec->sh_size, & relocs, & num_relocs))
13192             return FALSE;
13193         }
13194       else
13195         {
13196           if (!slurp_rel_relocs (filedata, relsec->sh_offset,
13197                                  relsec->sh_size, & relocs, & num_relocs))
13198             return FALSE;
13199         }
13200
13201       /* SH uses RELA but uses in place value instead of the addend field.  */
13202       if (filedata->file_header.e_machine == EM_SH)
13203         is_rela = FALSE;
13204
13205       symsec = filedata->section_headers + relsec->sh_link;
13206       if (symsec->sh_type != SHT_SYMTAB
13207           && symsec->sh_type != SHT_DYNSYM)
13208         return FALSE;
13209       symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
13210
13211       for (rp = relocs; rp < relocs + num_relocs; ++rp)
13212         {
13213           bfd_vma         addend;
13214           unsigned int    reloc_type;
13215           unsigned int    reloc_size;
13216           bfd_boolean     reloc_inplace = FALSE;
13217           bfd_boolean     reloc_subtract = FALSE;
13218           unsigned char * rloc;
13219           unsigned long   sym_index;
13220
13221           reloc_type = get_reloc_type (filedata, rp->r_info);
13222
13223           if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
13224             continue;
13225           else if (is_none_reloc (filedata, reloc_type))
13226             continue;
13227           else if (is_32bit_abs_reloc (filedata, reloc_type)
13228                    || is_32bit_pcrel_reloc (filedata, reloc_type))
13229             reloc_size = 4;
13230           else if (is_64bit_abs_reloc (filedata, reloc_type)
13231                    || is_64bit_pcrel_reloc (filedata, reloc_type))
13232             reloc_size = 8;
13233           else if (is_24bit_abs_reloc (filedata, reloc_type))
13234             reloc_size = 3;
13235           else if (is_16bit_abs_reloc (filedata, reloc_type))
13236             reloc_size = 2;
13237           else if (is_8bit_abs_reloc (filedata, reloc_type)
13238                    || is_6bit_abs_reloc (filedata, reloc_type))
13239             reloc_size = 1;
13240           else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
13241                                                                  reloc_type))
13242                    || is_32bit_inplace_add_reloc (filedata, reloc_type))
13243             {
13244               reloc_size = 4;
13245               reloc_inplace = TRUE;
13246             }
13247           else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
13248                                                                  reloc_type))
13249                    || is_64bit_inplace_add_reloc (filedata, reloc_type))
13250             {
13251               reloc_size = 8;
13252               reloc_inplace = TRUE;
13253             }
13254           else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
13255                                                                  reloc_type))
13256                    || is_16bit_inplace_add_reloc (filedata, reloc_type))
13257             {
13258               reloc_size = 2;
13259               reloc_inplace = TRUE;
13260             }
13261           else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
13262                                                                 reloc_type))
13263                    || is_8bit_inplace_add_reloc (filedata, reloc_type))
13264             {
13265               reloc_size = 1;
13266               reloc_inplace = TRUE;
13267             }
13268           else if ((reloc_subtract = is_6bit_inplace_sub_reloc (filedata,
13269                                                                 reloc_type)))
13270             {
13271               reloc_size = 1;
13272               reloc_inplace = TRUE;
13273             }
13274           else
13275             {
13276               static unsigned int prev_reloc = 0;
13277
13278               if (reloc_type != prev_reloc)
13279                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13280                       reloc_type, printable_section_name (filedata, section));
13281               prev_reloc = reloc_type;
13282               continue;
13283             }
13284
13285           rloc = start + rp->r_offset;
13286           if ((rloc + reloc_size) > end || (rloc < start))
13287             {
13288               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13289                     (unsigned long) rp->r_offset,
13290                     printable_section_name (filedata, section));
13291               continue;
13292             }
13293
13294           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
13295           if (sym_index >= num_syms)
13296             {
13297               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13298                     sym_index, printable_section_name (filedata, section));
13299               continue;
13300             }
13301           sym = symtab + sym_index;
13302
13303           /* If the reloc has a symbol associated with it,
13304              make sure that it is of an appropriate type.
13305
13306              Relocations against symbols without type can happen.
13307              Gcc -feliminate-dwarf2-dups may generate symbols
13308              without type for debug info.
13309
13310              Icc generates relocations against function symbols
13311              instead of local labels.
13312
13313              Relocations against object symbols can happen, eg when
13314              referencing a global array.  For an example of this see
13315              the _clz.o binary in libgcc.a.  */
13316           if (sym != symtab
13317               && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13318               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13319             {
13320               warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13321                     get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13322                     printable_section_name (filedata, relsec),
13323                     (long int)(rp - relocs));
13324               continue;
13325             }
13326
13327           addend = 0;
13328           if (is_rela)
13329             addend += rp->r_addend;
13330           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13331              partial_inplace.  */
13332           if (!is_rela
13333               || (filedata->file_header.e_machine == EM_XTENSA
13334                   && reloc_type == 1)
13335               || ((filedata->file_header.e_machine == EM_PJ
13336                    || filedata->file_header.e_machine == EM_PJ_OLD)
13337                   && reloc_type == 1)
13338               || ((filedata->file_header.e_machine == EM_D30V
13339                    || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13340                   && reloc_type == 12)
13341               || reloc_inplace)
13342             {
13343               if (is_6bit_inplace_sub_reloc (filedata, reloc_type))
13344                 addend += byte_get (rloc, reloc_size) & 0x3f;
13345               else
13346                 addend += byte_get (rloc, reloc_size);
13347             }
13348
13349           if (is_32bit_pcrel_reloc (filedata, reloc_type)
13350               || is_64bit_pcrel_reloc (filedata, reloc_type))
13351             {
13352               /* On HPPA, all pc-relative relocations are biased by 8.  */
13353               if (filedata->file_header.e_machine == EM_PARISC)
13354                 addend -= 8;
13355               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13356                         reloc_size);
13357             }
13358           else if (is_6bit_abs_reloc (filedata, reloc_type)
13359                    || is_6bit_inplace_sub_reloc (filedata, reloc_type))
13360             {
13361               if (reloc_subtract)
13362                 addend -= sym->st_value;
13363               else
13364                 addend += sym->st_value;
13365               addend = (addend & 0x3f) | (byte_get (rloc, reloc_size) & 0xc0);
13366               byte_put (rloc, addend, reloc_size);
13367             }
13368           else if (reloc_subtract)
13369             byte_put (rloc, addend - sym->st_value, reloc_size);
13370           else
13371             byte_put (rloc, addend + sym->st_value, reloc_size);
13372         }
13373
13374       free (symtab);
13375       /* Let the target specific reloc processing code know that
13376          we have finished with these relocs.  */
13377       target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13378
13379       if (relocs_return)
13380         {
13381           * (Elf_Internal_Rela **) relocs_return = relocs;
13382           * num_relocs_return = num_relocs;
13383         }
13384       else
13385         free (relocs);
13386
13387       break;
13388     }
13389
13390   return TRUE;
13391 }
13392
13393 #ifdef SUPPORT_DISASSEMBLY
13394 static bfd_boolean
13395 disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13396 {
13397   printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13398
13399   /* FIXME: XXX -- to be done --- XXX */
13400
13401   return TRUE;
13402 }
13403 #endif
13404
13405 /* Reads in the contents of SECTION from FILE, returning a pointer
13406    to a malloc'ed buffer or NULL if something went wrong.  */
13407
13408 static char *
13409 get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13410 {
13411   bfd_size_type num_bytes = section->sh_size;
13412
13413   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13414     {
13415       printf (_("Section '%s' has no data to dump.\n"),
13416               printable_section_name (filedata, section));
13417       return NULL;
13418     }
13419
13420   return  (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13421                              _("section contents"));
13422 }
13423
13424 /* Uncompresses a section that was compressed using zlib, in place.  */
13425
13426 static bfd_boolean
13427 uncompress_section_contents (unsigned char **   buffer,
13428                              dwarf_size_type    uncompressed_size,
13429                              dwarf_size_type *  size)
13430 {
13431   dwarf_size_type compressed_size = *size;
13432   unsigned char * compressed_buffer = *buffer;
13433   unsigned char * uncompressed_buffer;
13434   z_stream strm;
13435   int rc;
13436
13437   /* It is possible the section consists of several compressed
13438      buffers concatenated together, so we uncompress in a loop.  */
13439   /* PR 18313: The state field in the z_stream structure is supposed
13440      to be invisible to the user (ie us), but some compilers will
13441      still complain about it being used without initialisation.  So
13442      we first zero the entire z_stream structure and then set the fields
13443      that we need.  */
13444   memset (& strm, 0, sizeof strm);
13445   strm.avail_in = compressed_size;
13446   strm.next_in = (Bytef *) compressed_buffer;
13447   strm.avail_out = uncompressed_size;
13448   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13449
13450   rc = inflateInit (& strm);
13451   while (strm.avail_in > 0)
13452     {
13453       if (rc != Z_OK)
13454         goto fail;
13455       strm.next_out = ((Bytef *) uncompressed_buffer
13456                        + (uncompressed_size - strm.avail_out));
13457       rc = inflate (&strm, Z_FINISH);
13458       if (rc != Z_STREAM_END)
13459         goto fail;
13460       rc = inflateReset (& strm);
13461     }
13462   rc = inflateEnd (& strm);
13463   if (rc != Z_OK
13464       || strm.avail_out != 0)
13465     goto fail;
13466
13467   *buffer = uncompressed_buffer;
13468   *size = uncompressed_size;
13469   return TRUE;
13470
13471  fail:
13472   free (uncompressed_buffer);
13473   /* Indicate decompression failure.  */
13474   *buffer = NULL;
13475   return FALSE;
13476 }
13477
13478 static bfd_boolean
13479 dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13480 {
13481   Elf_Internal_Shdr *  relsec;
13482   bfd_size_type        num_bytes;
13483   unsigned char *      data;
13484   unsigned char *      end;
13485   unsigned char *      real_start;
13486   unsigned char *      start;
13487   bfd_boolean          some_strings_shown;
13488
13489   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13490   if (start == NULL)
13491     /* PR 21820: Do not fail if the section was empty.  */
13492     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13493
13494   num_bytes = section->sh_size;
13495
13496   printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13497
13498   if (decompress_dumps)
13499     {
13500       dwarf_size_type new_size = num_bytes;
13501       dwarf_size_type uncompressed_size = 0;
13502
13503       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13504         {
13505           Elf_Internal_Chdr chdr;
13506           unsigned int compression_header_size
13507             = get_compression_header (& chdr, (unsigned char *) start,
13508                                       num_bytes);
13509
13510           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13511             {
13512               warn (_("section '%s' has unsupported compress type: %d\n"),
13513                     printable_section_name (filedata, section), chdr.ch_type);
13514               return FALSE;
13515             }
13516           uncompressed_size = chdr.ch_size;
13517           start += compression_header_size;
13518           new_size -= compression_header_size;
13519         }
13520       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13521         {
13522           /* Read the zlib header.  In this case, it should be "ZLIB"
13523              followed by the uncompressed section size, 8 bytes in
13524              big-endian order.  */
13525           uncompressed_size = start[4]; uncompressed_size <<= 8;
13526           uncompressed_size += start[5]; uncompressed_size <<= 8;
13527           uncompressed_size += start[6]; uncompressed_size <<= 8;
13528           uncompressed_size += start[7]; uncompressed_size <<= 8;
13529           uncompressed_size += start[8]; uncompressed_size <<= 8;
13530           uncompressed_size += start[9]; uncompressed_size <<= 8;
13531           uncompressed_size += start[10]; uncompressed_size <<= 8;
13532           uncompressed_size += start[11];
13533           start += 12;
13534           new_size -= 12;
13535         }
13536
13537       if (uncompressed_size)
13538         {
13539           if (uncompress_section_contents (& start,
13540                                            uncompressed_size, & new_size))
13541             num_bytes = new_size;
13542           else
13543             {
13544               error (_("Unable to decompress section %s\n"),
13545                      printable_section_name (filedata, section));
13546               return FALSE;
13547             }
13548         }
13549       else
13550         start = real_start;
13551     }
13552
13553   /* If the section being dumped has relocations against it the user might
13554      be expecting these relocations to have been applied.  Check for this
13555      case and issue a warning message in order to avoid confusion.
13556      FIXME: Maybe we ought to have an option that dumps a section with
13557      relocs applied ?  */
13558   for (relsec = filedata->section_headers;
13559        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13560        ++relsec)
13561     {
13562       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13563           || relsec->sh_info >= filedata->file_header.e_shnum
13564           || filedata->section_headers + relsec->sh_info != section
13565           || relsec->sh_size == 0
13566           || relsec->sh_link >= filedata->file_header.e_shnum)
13567         continue;
13568
13569       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13570       break;
13571     }
13572
13573   data = start;
13574   end  = start + num_bytes;
13575   some_strings_shown = FALSE;
13576
13577   while (data < end)
13578     {
13579       while (!ISPRINT (* data))
13580         if (++ data >= end)
13581           break;
13582
13583       if (data < end)
13584         {
13585           size_t maxlen = end - data;
13586
13587 #ifndef __MSVCRT__
13588           /* PR 11128: Use two separate invocations in order to work
13589              around bugs in the Solaris 8 implementation of printf.  */
13590           printf ("  [%6tx]  ", data - start);
13591 #else
13592           printf ("  [%6Ix]  ", (size_t) (data - start));
13593 #endif
13594           if (maxlen > 0)
13595             {
13596               print_symbol ((int) maxlen, (const char *) data);
13597               putchar ('\n');
13598               data += strnlen ((const char *) data, maxlen);
13599             }
13600           else
13601             {
13602               printf (_("<corrupt>\n"));
13603               data = end;
13604             }
13605           some_strings_shown = TRUE;
13606         }
13607     }
13608
13609   if (! some_strings_shown)
13610     printf (_("  No strings found in this section."));
13611
13612   free (real_start);
13613
13614   putchar ('\n');
13615   return TRUE;
13616 }
13617
13618 static bfd_boolean
13619 dump_section_as_bytes (Elf_Internal_Shdr *  section,
13620                        Filedata *           filedata,
13621                        bfd_boolean          relocate)
13622 {
13623   Elf_Internal_Shdr * relsec;
13624   bfd_size_type       bytes;
13625   bfd_size_type       section_size;
13626   bfd_vma             addr;
13627   unsigned char *     data;
13628   unsigned char *     real_start;
13629   unsigned char *     start;
13630
13631   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13632   if (start == NULL)
13633     /* PR 21820: Do not fail if the section was empty.  */
13634     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13635
13636   section_size = section->sh_size;
13637
13638   printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13639
13640   if (decompress_dumps)
13641     {
13642       dwarf_size_type new_size = section_size;
13643       dwarf_size_type uncompressed_size = 0;
13644
13645       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13646         {
13647           Elf_Internal_Chdr chdr;
13648           unsigned int compression_header_size
13649             = get_compression_header (& chdr, start, section_size);
13650
13651           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13652             {
13653               warn (_("section '%s' has unsupported compress type: %d\n"),
13654                     printable_section_name (filedata, section), chdr.ch_type);
13655               return FALSE;
13656             }
13657           uncompressed_size = chdr.ch_size;
13658           start += compression_header_size;
13659           new_size -= compression_header_size;
13660         }
13661       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13662         {
13663           /* Read the zlib header.  In this case, it should be "ZLIB"
13664              followed by the uncompressed section size, 8 bytes in
13665              big-endian order.  */
13666           uncompressed_size = start[4]; uncompressed_size <<= 8;
13667           uncompressed_size += start[5]; uncompressed_size <<= 8;
13668           uncompressed_size += start[6]; uncompressed_size <<= 8;
13669           uncompressed_size += start[7]; uncompressed_size <<= 8;
13670           uncompressed_size += start[8]; uncompressed_size <<= 8;
13671           uncompressed_size += start[9]; uncompressed_size <<= 8;
13672           uncompressed_size += start[10]; uncompressed_size <<= 8;
13673           uncompressed_size += start[11];
13674           start += 12;
13675           new_size -= 12;
13676         }
13677
13678       if (uncompressed_size)
13679         {
13680           if (uncompress_section_contents (& start, uncompressed_size,
13681                                            & new_size))
13682             {
13683               section_size = new_size;
13684             }
13685           else
13686             {
13687               error (_("Unable to decompress section %s\n"),
13688                      printable_section_name (filedata, section));
13689               /* FIXME: Print the section anyway ?  */
13690               return FALSE;
13691             }
13692         }
13693       else
13694         start = real_start;
13695     }
13696
13697   if (relocate)
13698     {
13699       if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
13700         return FALSE;
13701     }
13702   else
13703     {
13704       /* If the section being dumped has relocations against it the user might
13705          be expecting these relocations to have been applied.  Check for this
13706          case and issue a warning message in order to avoid confusion.
13707          FIXME: Maybe we ought to have an option that dumps a section with
13708          relocs applied ?  */
13709       for (relsec = filedata->section_headers;
13710            relsec < filedata->section_headers + filedata->file_header.e_shnum;
13711            ++relsec)
13712         {
13713           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13714               || relsec->sh_info >= filedata->file_header.e_shnum
13715               || filedata->section_headers + relsec->sh_info != section
13716               || relsec->sh_size == 0
13717               || relsec->sh_link >= filedata->file_header.e_shnum)
13718             continue;
13719
13720           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13721           break;
13722         }
13723     }
13724
13725   addr = section->sh_addr;
13726   bytes = section_size;
13727   data = start;
13728
13729   while (bytes)
13730     {
13731       int j;
13732       int k;
13733       int lbytes;
13734
13735       lbytes = (bytes > 16 ? 16 : bytes);
13736
13737       printf ("  0x%8.8lx ", (unsigned long) addr);
13738
13739       for (j = 0; j < 16; j++)
13740         {
13741           if (j < lbytes)
13742             printf ("%2.2x", data[j]);
13743           else
13744             printf ("  ");
13745
13746           if ((j & 3) == 3)
13747             printf (" ");
13748         }
13749
13750       for (j = 0; j < lbytes; j++)
13751         {
13752           k = data[j];
13753           if (k >= ' ' && k < 0x7f)
13754             printf ("%c", k);
13755           else
13756             printf (".");
13757         }
13758
13759       putchar ('\n');
13760
13761       data  += lbytes;
13762       addr  += lbytes;
13763       bytes -= lbytes;
13764     }
13765
13766   free (real_start);
13767
13768   putchar ('\n');
13769   return TRUE;
13770 }
13771
13772 static bfd_boolean
13773 load_specific_debug_section (enum dwarf_section_display_enum  debug,
13774                              const Elf_Internal_Shdr *        sec,
13775                              void *                           data)
13776 {
13777   struct dwarf_section * section = &debug_displays [debug].section;
13778   char buf [64];
13779   Filedata * filedata = (Filedata *) data;
13780
13781   if (section->start != NULL)
13782     {
13783       /* If it is already loaded, do nothing.  */
13784       if (streq (section->filename, filedata->file_name))
13785         return TRUE;
13786       free (section->start);
13787     }
13788
13789   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13790   section->address = sec->sh_addr;
13791   section->user_data = NULL;
13792   section->filename = filedata->file_name;
13793   section->start = (unsigned char *) get_data (NULL, filedata,
13794                                                sec->sh_offset, 1,
13795                                                sec->sh_size, buf);
13796   if (section->start == NULL)
13797     section->size = 0;
13798   else
13799     {
13800       unsigned char *start = section->start;
13801       dwarf_size_type size = sec->sh_size;
13802       dwarf_size_type uncompressed_size = 0;
13803
13804       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13805         {
13806           Elf_Internal_Chdr chdr;
13807           unsigned int compression_header_size;
13808
13809           if (size < (is_32bit_elf
13810                       ? sizeof (Elf32_External_Chdr)
13811                       : sizeof (Elf64_External_Chdr)))
13812             {
13813               warn (_("compressed section %s is too small to contain a compression header"),
13814                     section->name);
13815               return FALSE;
13816             }
13817
13818           compression_header_size = get_compression_header (&chdr, start, size);
13819
13820           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13821             {
13822               warn (_("section '%s' has unsupported compress type: %d\n"),
13823                     section->name, chdr.ch_type);
13824               return FALSE;
13825             }
13826           uncompressed_size = chdr.ch_size;
13827           start += compression_header_size;
13828           size -= compression_header_size;
13829         }
13830       else if (size > 12 && streq ((char *) start, "ZLIB"))
13831         {
13832           /* Read the zlib header.  In this case, it should be "ZLIB"
13833              followed by the uncompressed section size, 8 bytes in
13834              big-endian order.  */
13835           uncompressed_size = start[4]; uncompressed_size <<= 8;
13836           uncompressed_size += start[5]; uncompressed_size <<= 8;
13837           uncompressed_size += start[6]; uncompressed_size <<= 8;
13838           uncompressed_size += start[7]; uncompressed_size <<= 8;
13839           uncompressed_size += start[8]; uncompressed_size <<= 8;
13840           uncompressed_size += start[9]; uncompressed_size <<= 8;
13841           uncompressed_size += start[10]; uncompressed_size <<= 8;
13842           uncompressed_size += start[11];
13843           start += 12;
13844           size -= 12;
13845         }
13846
13847       if (uncompressed_size)
13848         {
13849           if (uncompress_section_contents (&start, uncompressed_size,
13850                                            &size))
13851             {
13852               /* Free the compressed buffer, update the section buffer
13853                  and the section size if uncompress is successful.  */
13854               free (section->start);
13855               section->start = start;
13856             }
13857           else
13858             {
13859               error (_("Unable to decompress section %s\n"),
13860                      printable_section_name (filedata, sec));
13861               return FALSE;
13862             }
13863         }
13864
13865       section->size = size;
13866     }
13867
13868   if (section->start == NULL)
13869     return FALSE;
13870
13871   if (debug_displays [debug].relocate)
13872     {
13873       if (! apply_relocations (filedata, sec, section->start, section->size,
13874                                & section->reloc_info, & section->num_relocs))
13875         return FALSE;
13876     }
13877   else
13878     {
13879       section->reloc_info = NULL;
13880       section->num_relocs = 0;
13881     }
13882
13883   return TRUE;
13884 }
13885
13886 /* If this is not NULL, load_debug_section will only look for sections
13887    within the list of sections given here.  */
13888 static unsigned int * section_subset = NULL;
13889
13890 bfd_boolean
13891 load_debug_section (enum dwarf_section_display_enum debug, void * data)
13892 {
13893   struct dwarf_section * section = &debug_displays [debug].section;
13894   Elf_Internal_Shdr * sec;
13895   Filedata * filedata = (Filedata *) data;
13896
13897   /* Without section headers we cannot find any sections.  */
13898   if (filedata->section_headers == NULL)
13899     return FALSE;
13900
13901   if (filedata->string_table == NULL
13902       && filedata->file_header.e_shstrndx != SHN_UNDEF
13903       && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
13904     {
13905       Elf_Internal_Shdr * strs;
13906
13907       /* Read in the string table, so that we have section names to scan.  */
13908       strs = filedata->section_headers + filedata->file_header.e_shstrndx;
13909
13910       if (strs != NULL && strs->sh_size != 0)
13911         {
13912           filedata->string_table
13913             = (char *) get_data (NULL, filedata, strs->sh_offset,
13914                                  1, strs->sh_size, _("string table"));
13915
13916           filedata->string_table_length
13917             = filedata->string_table != NULL ? strs->sh_size : 0;
13918         }
13919     }
13920
13921   /* Locate the debug section.  */
13922   sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
13923   if (sec != NULL)
13924     section->name = section->uncompressed_name;
13925   else
13926     {
13927       sec = find_section_in_set (filedata, section->compressed_name, section_subset);
13928       if (sec != NULL)
13929         section->name = section->compressed_name;
13930     }
13931   if (sec == NULL)
13932     return FALSE;
13933
13934   /* If we're loading from a subset of sections, and we've loaded
13935      a section matching this name before, it's likely that it's a
13936      different one.  */
13937   if (section_subset != NULL)
13938     free_debug_section (debug);
13939
13940   return load_specific_debug_section (debug, sec, data);
13941 }
13942
13943 void
13944 free_debug_section (enum dwarf_section_display_enum debug)
13945 {
13946   struct dwarf_section * section = &debug_displays [debug].section;
13947
13948   if (section->start == NULL)
13949     return;
13950
13951   free ((char *) section->start);
13952   section->start = NULL;
13953   section->address = 0;
13954   section->size = 0;
13955 }
13956
13957 static bfd_boolean
13958 display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
13959 {
13960   char * name = SECTION_NAME (section);
13961   const char * print_name = printable_section_name (filedata, section);
13962   bfd_size_type length;
13963   bfd_boolean result = TRUE;
13964   int i;
13965
13966   length = section->sh_size;
13967   if (length == 0)
13968     {
13969       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13970       return TRUE;
13971     }
13972   if (section->sh_type == SHT_NOBITS)
13973     {
13974       /* There is no point in dumping the contents of a debugging section
13975          which has the NOBITS type - the bits in the file will be random.
13976          This can happen when a file containing a .eh_frame section is
13977          stripped with the --only-keep-debug command line option.  */
13978       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13979               print_name);
13980       return FALSE;
13981     }
13982
13983   if (const_strneq (name, ".gnu.linkonce.wi."))
13984     name = ".debug_info";
13985
13986   /* See if we know how to display the contents of this section.  */
13987   for (i = 0; i < max; i++)
13988     {
13989       enum dwarf_section_display_enum  id = (enum dwarf_section_display_enum) i;
13990       struct dwarf_section_display *   display = debug_displays + i;
13991       struct dwarf_section *           sec = & display->section;
13992
13993       if (streq (sec->uncompressed_name, name)
13994           || (id == line && const_strneq (name, ".debug_line."))
13995           || streq (sec->compressed_name, name))
13996         {
13997           bfd_boolean secondary = (section != find_section (filedata, name));
13998
13999           if (secondary)
14000             free_debug_section (id);
14001
14002           if (i == line && const_strneq (name, ".debug_line."))
14003             sec->name = name;
14004           else if (streq (sec->uncompressed_name, name))
14005             sec->name = sec->uncompressed_name;
14006           else
14007             sec->name = sec->compressed_name;
14008
14009           if (load_specific_debug_section (id, section, filedata))
14010             {
14011               /* If this debug section is part of a CU/TU set in a .dwp file,
14012                  restrict load_debug_section to the sections in that set.  */
14013               section_subset = find_cu_tu_set (filedata, shndx);
14014
14015               result &= display->display (sec, filedata);
14016
14017               section_subset = NULL;
14018
14019               if (secondary || (id != info && id != abbrev))
14020                 free_debug_section (id);
14021             }
14022           break;
14023         }
14024     }
14025
14026   if (i == max)
14027     {
14028       printf (_("Unrecognized debug section: %s\n"), print_name);
14029       result = FALSE;
14030     }
14031
14032   return result;
14033 }
14034
14035 /* Set DUMP_SECTS for all sections where dumps were requested
14036    based on section name.  */
14037
14038 static void
14039 initialise_dumps_byname (Filedata * filedata)
14040 {
14041   struct dump_list_entry * cur;
14042
14043   for (cur = dump_sects_byname; cur; cur = cur->next)
14044     {
14045       unsigned int i;
14046       bfd_boolean any = FALSE;
14047
14048       for (i = 0; i < filedata->file_header.e_shnum; i++)
14049         if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
14050           {
14051             request_dump_bynumber (filedata, i, cur->type);
14052             any = TRUE;
14053           }
14054
14055       if (!any)
14056         warn (_("Section '%s' was not dumped because it does not exist!\n"),
14057               cur->name);
14058     }
14059 }
14060
14061 static bfd_boolean
14062 process_section_contents (Filedata * filedata)
14063 {
14064   Elf_Internal_Shdr * section;
14065   unsigned int i;
14066   bfd_boolean res = TRUE;
14067
14068   if (! do_dump)
14069     return TRUE;
14070
14071   initialise_dumps_byname (filedata);
14072
14073   for (i = 0, section = filedata->section_headers;
14074        i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
14075        i++, section++)
14076     {
14077       dump_type dump = filedata->dump_sects[i];
14078
14079 #ifdef SUPPORT_DISASSEMBLY
14080       if (dump & DISASS_DUMP)
14081         {
14082           if (! disassemble_section (section, filedata))
14083             res = FALSE;
14084         }
14085 #endif
14086       if (dump & HEX_DUMP)
14087         {
14088           if (! dump_section_as_bytes (section, filedata, FALSE))
14089             res = FALSE;
14090         }
14091
14092       if (dump & RELOC_DUMP)
14093         {
14094           if (! dump_section_as_bytes (section, filedata, TRUE))
14095             res = FALSE;
14096         }
14097
14098       if (dump & STRING_DUMP)
14099         {
14100           if (! dump_section_as_strings (section, filedata))
14101             res = FALSE;
14102         }
14103
14104       if (dump & DEBUG_DUMP)
14105         {
14106           if (! display_debug_section (i, section, filedata))
14107             res = FALSE;
14108         }
14109     }
14110
14111   /* Check to see if the user requested a
14112      dump of a section that does not exist.  */
14113   while (i < filedata->num_dump_sects)
14114     {
14115       if (filedata->dump_sects[i])
14116         {
14117           warn (_("Section %d was not dumped because it does not exist!\n"), i);
14118           res = FALSE;
14119         }
14120       i++;
14121     }
14122
14123   return res;
14124 }
14125
14126 static void
14127 process_mips_fpe_exception (int mask)
14128 {
14129   if (mask)
14130     {
14131       bfd_boolean first = TRUE;
14132
14133       if (mask & OEX_FPU_INEX)
14134         fputs ("INEX", stdout), first = FALSE;
14135       if (mask & OEX_FPU_UFLO)
14136         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
14137       if (mask & OEX_FPU_OFLO)
14138         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
14139       if (mask & OEX_FPU_DIV0)
14140         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
14141       if (mask & OEX_FPU_INVAL)
14142         printf ("%sINVAL", first ? "" : "|");
14143     }
14144   else
14145     fputs ("0", stdout);
14146 }
14147
14148 /* Display's the value of TAG at location P.  If TAG is
14149    greater than 0 it is assumed to be an unknown tag, and
14150    a message is printed to this effect.  Otherwise it is
14151    assumed that a message has already been printed.
14152
14153    If the bottom bit of TAG is set it assumed to have a
14154    string value, otherwise it is assumed to have an integer
14155    value.
14156
14157    Returns an updated P pointing to the first unread byte
14158    beyond the end of TAG's value.
14159
14160    Reads at or beyond END will not be made.  */
14161
14162 static unsigned char *
14163 display_tag_value (signed int tag,
14164                    unsigned char * p,
14165                    const unsigned char * const end)
14166 {
14167   unsigned long val;
14168
14169   if (tag > 0)
14170     printf ("  Tag_unknown_%d: ", tag);
14171
14172   if (p >= end)
14173     {
14174       warn (_("<corrupt tag>\n"));
14175     }
14176   else if (tag & 1)
14177     {
14178       /* PR 17531 file: 027-19978-0.004.  */
14179       size_t maxlen = (end - p) - 1;
14180
14181       putchar ('"');
14182       if (maxlen > 0)
14183         {
14184           print_symbol ((int) maxlen, (const char *) p);
14185           p += strnlen ((char *) p, maxlen) + 1;
14186         }
14187       else
14188         {
14189           printf (_("<corrupt string tag>"));
14190           p = (unsigned char *) end;
14191         }
14192       printf ("\"\n");
14193     }
14194   else
14195     {
14196       unsigned int len;
14197
14198       val = read_uleb128 (p, &len, end);
14199       p += len;
14200       printf ("%ld (0x%lx)\n", val, val);
14201     }
14202
14203   assert (p <= end);
14204   return p;
14205 }
14206
14207 /* ARC ABI attributes section.  */
14208
14209 static unsigned char *
14210 display_arc_attribute (unsigned char * p,
14211                        const unsigned char * const end)
14212 {
14213   unsigned int tag;
14214   unsigned int len;
14215   unsigned int val;
14216
14217   tag = read_uleb128 (p, &len, end);
14218   p += len;
14219
14220   switch (tag)
14221     {
14222     case Tag_ARC_PCS_config:
14223       val = read_uleb128 (p, &len, end);
14224       p += len;
14225       printf ("  Tag_ARC_PCS_config: ");
14226       switch (val)
14227         {
14228         case 0:
14229           printf (_("Absent/Non standard\n"));
14230           break;
14231         case 1:
14232           printf (_("Bare metal/mwdt\n"));
14233           break;
14234         case 2:
14235           printf (_("Bare metal/newlib\n"));
14236           break;
14237         case 3:
14238           printf (_("Linux/uclibc\n"));
14239           break;
14240         case 4:
14241           printf (_("Linux/glibc\n"));
14242           break;
14243         default:
14244           printf (_("Unknown\n"));
14245           break;
14246         }
14247       break;
14248
14249     case Tag_ARC_CPU_base:
14250       val = read_uleb128 (p, &len, end);
14251       p += len;
14252       printf ("  Tag_ARC_CPU_base: ");
14253       switch (val)
14254         {
14255         default:
14256         case TAG_CPU_NONE:
14257           printf (_("Absent\n"));
14258           break;
14259         case TAG_CPU_ARC6xx:
14260           printf ("ARC6xx\n");
14261           break;
14262         case TAG_CPU_ARC7xx:
14263           printf ("ARC7xx\n");
14264           break;
14265         case TAG_CPU_ARCEM:
14266           printf ("ARCEM\n");
14267           break;
14268         case TAG_CPU_ARCHS:
14269           printf ("ARCHS\n");
14270           break;
14271         }
14272       break;
14273
14274     case Tag_ARC_CPU_variation:
14275       val = read_uleb128 (p, &len, end);
14276       p += len;
14277       printf ("  Tag_ARC_CPU_variation: ");
14278       switch (val)
14279         {
14280         default:
14281           if (val > 0 && val < 16)
14282               printf ("Core%d\n", val);
14283           else
14284               printf ("Unknown\n");
14285           break;
14286
14287         case 0:
14288           printf (_("Absent\n"));
14289           break;
14290         }
14291       break;
14292
14293     case Tag_ARC_CPU_name:
14294       printf ("  Tag_ARC_CPU_name: ");
14295       p = display_tag_value (-1, p, end);
14296       break;
14297
14298     case Tag_ARC_ABI_rf16:
14299       val = read_uleb128 (p, &len, end);
14300       p += len;
14301       printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
14302       break;
14303
14304     case Tag_ARC_ABI_osver:
14305       val = read_uleb128 (p, &len, end);
14306       p += len;
14307       printf ("  Tag_ARC_ABI_osver: v%d\n", val);
14308       break;
14309
14310     case Tag_ARC_ABI_pic:
14311     case Tag_ARC_ABI_sda:
14312       val = read_uleb128 (p, &len, end);
14313       p += len;
14314       printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
14315               : "  Tag_ARC_ABI_pic: ");
14316       switch (val)
14317         {
14318         case 0:
14319           printf (_("Absent\n"));
14320           break;
14321         case 1:
14322           printf ("MWDT\n");
14323           break;
14324         case 2:
14325           printf ("GNU\n");
14326           break;
14327         default:
14328           printf (_("Unknown\n"));
14329           break;
14330         }
14331       break;
14332
14333     case Tag_ARC_ABI_tls:
14334       val = read_uleb128 (p, &len, end);
14335       p += len;
14336       printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14337       break;
14338
14339     case Tag_ARC_ABI_enumsize:
14340       val = read_uleb128 (p, &len, end);
14341       p += len;
14342       printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14343               _("smallest"));
14344       break;
14345
14346     case Tag_ARC_ABI_exceptions:
14347       val = read_uleb128 (p, &len, end);
14348       p += len;
14349       printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14350               : _("default"));
14351       break;
14352
14353     case Tag_ARC_ABI_double_size:
14354       val = read_uleb128 (p, &len, end);
14355       p += len;
14356       printf ("  Tag_ARC_ABI_double_size: %d\n", val);
14357       break;
14358
14359     case Tag_ARC_ISA_config:
14360       printf ("  Tag_ARC_ISA_config: ");
14361       p = display_tag_value (-1, p, end);
14362       break;
14363
14364     case Tag_ARC_ISA_apex:
14365       printf ("  Tag_ARC_ISA_apex: ");
14366       p = display_tag_value (-1, p, end);
14367       break;
14368
14369     case Tag_ARC_ISA_mpy_option:
14370       val = read_uleb128 (p, &len, end);
14371       p += len;
14372       printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
14373       break;
14374
14375     case Tag_ARC_ATR_version:
14376       val = read_uleb128 (p, &len, end);
14377       p += len;
14378       printf ("  Tag_ARC_ATR_version: %d\n", val);
14379       break;
14380
14381     default:
14382       return display_tag_value (tag & 1, p, end);
14383     }
14384
14385   return p;
14386 }
14387
14388 /* ARM EABI attributes section.  */
14389 typedef struct
14390 {
14391   unsigned int tag;
14392   const char * name;
14393   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
14394   unsigned int type;
14395   const char ** table;
14396 } arm_attr_public_tag;
14397
14398 static const char * arm_attr_tag_CPU_arch[] =
14399   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14400    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14401    "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
14402 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14403 static const char * arm_attr_tag_THUMB_ISA_use[] =
14404   {"No", "Thumb-1", "Thumb-2", "Yes"};
14405 static const char * arm_attr_tag_FP_arch[] =
14406   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14407    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14408 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14409 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14410   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14411    "NEON for ARMv8.1"};
14412 static const char * arm_attr_tag_PCS_config[] =
14413   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14414    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14415 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14416   {"V6", "SB", "TLS", "Unused"};
14417 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14418   {"Absolute", "PC-relative", "SB-relative", "None"};
14419 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14420   {"Absolute", "PC-relative", "None"};
14421 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14422   {"None", "direct", "GOT-indirect"};
14423 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14424   {"None", "??? 1", "2", "??? 3", "4"};
14425 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14426 static const char * arm_attr_tag_ABI_FP_denormal[] =
14427   {"Unused", "Needed", "Sign only"};
14428 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14429 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14430 static const char * arm_attr_tag_ABI_FP_number_model[] =
14431   {"Unused", "Finite", "RTABI", "IEEE 754"};
14432 static const char * arm_attr_tag_ABI_enum_size[] =
14433   {"Unused", "small", "int", "forced to int"};
14434 static const char * arm_attr_tag_ABI_HardFP_use[] =
14435   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14436 static const char * arm_attr_tag_ABI_VFP_args[] =
14437   {"AAPCS", "VFP registers", "custom", "compatible"};
14438 static const char * arm_attr_tag_ABI_WMMX_args[] =
14439   {"AAPCS", "WMMX registers", "custom"};
14440 static const char * arm_attr_tag_ABI_optimization_goals[] =
14441   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14442     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14443 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14444   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14445     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14446 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14447 static const char * arm_attr_tag_FP_HP_extension[] =
14448   {"Not Allowed", "Allowed"};
14449 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14450   {"None", "IEEE 754", "Alternative Format"};
14451 static const char * arm_attr_tag_DSP_extension[] =
14452   {"Follow architecture", "Allowed"};
14453 static const char * arm_attr_tag_MPextension_use[] =
14454   {"Not Allowed", "Allowed"};
14455 static const char * arm_attr_tag_DIV_use[] =
14456   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14457     "Allowed in v7-A with integer division extension"};
14458 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14459 static const char * arm_attr_tag_Virtualization_use[] =
14460   {"Not Allowed", "TrustZone", "Virtualization Extensions",
14461     "TrustZone and Virtualization Extensions"};
14462 static const char * arm_attr_tag_MPextension_use_legacy[] =
14463   {"Not Allowed", "Allowed"};
14464
14465 static const char * arm_attr_tag_MVE_arch[] =
14466   {"No MVE", "MVE Integer only", "MVE Integer and FP"};
14467
14468 #define LOOKUP(id, name) \
14469   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14470 static arm_attr_public_tag arm_attr_public_tags[] =
14471 {
14472   {4, "CPU_raw_name", 1, NULL},
14473   {5, "CPU_name", 1, NULL},
14474   LOOKUP(6, CPU_arch),
14475   {7, "CPU_arch_profile", 0, NULL},
14476   LOOKUP(8, ARM_ISA_use),
14477   LOOKUP(9, THUMB_ISA_use),
14478   LOOKUP(10, FP_arch),
14479   LOOKUP(11, WMMX_arch),
14480   LOOKUP(12, Advanced_SIMD_arch),
14481   LOOKUP(13, PCS_config),
14482   LOOKUP(14, ABI_PCS_R9_use),
14483   LOOKUP(15, ABI_PCS_RW_data),
14484   LOOKUP(16, ABI_PCS_RO_data),
14485   LOOKUP(17, ABI_PCS_GOT_use),
14486   LOOKUP(18, ABI_PCS_wchar_t),
14487   LOOKUP(19, ABI_FP_rounding),
14488   LOOKUP(20, ABI_FP_denormal),
14489   LOOKUP(21, ABI_FP_exceptions),
14490   LOOKUP(22, ABI_FP_user_exceptions),
14491   LOOKUP(23, ABI_FP_number_model),
14492   {24, "ABI_align_needed", 0, NULL},
14493   {25, "ABI_align_preserved", 0, NULL},
14494   LOOKUP(26, ABI_enum_size),
14495   LOOKUP(27, ABI_HardFP_use),
14496   LOOKUP(28, ABI_VFP_args),
14497   LOOKUP(29, ABI_WMMX_args),
14498   LOOKUP(30, ABI_optimization_goals),
14499   LOOKUP(31, ABI_FP_optimization_goals),
14500   {32, "compatibility", 0, NULL},
14501   LOOKUP(34, CPU_unaligned_access),
14502   LOOKUP(36, FP_HP_extension),
14503   LOOKUP(38, ABI_FP_16bit_format),
14504   LOOKUP(42, MPextension_use),
14505   LOOKUP(44, DIV_use),
14506   LOOKUP(46, DSP_extension),
14507   LOOKUP(48, MVE_arch),
14508   {64, "nodefaults", 0, NULL},
14509   {65, "also_compatible_with", 0, NULL},
14510   LOOKUP(66, T2EE_use),
14511   {67, "conformance", 1, NULL},
14512   LOOKUP(68, Virtualization_use),
14513   LOOKUP(70, MPextension_use_legacy)
14514 };
14515 #undef LOOKUP
14516
14517 static unsigned char *
14518 display_arm_attribute (unsigned char * p,
14519                        const unsigned char * const end)
14520 {
14521   unsigned int tag;
14522   unsigned int len;
14523   unsigned int val;
14524   arm_attr_public_tag * attr;
14525   unsigned i;
14526   unsigned int type;
14527
14528   tag = read_uleb128 (p, &len, end);
14529   p += len;
14530   attr = NULL;
14531   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14532     {
14533       if (arm_attr_public_tags[i].tag == tag)
14534         {
14535           attr = &arm_attr_public_tags[i];
14536           break;
14537         }
14538     }
14539
14540   if (attr)
14541     {
14542       printf ("  Tag_%s: ", attr->name);
14543       switch (attr->type)
14544         {
14545         case 0:
14546           switch (tag)
14547             {
14548             case 7: /* Tag_CPU_arch_profile.  */
14549               val = read_uleb128 (p, &len, end);
14550               p += len;
14551               switch (val)
14552                 {
14553                 case 0: printf (_("None\n")); break;
14554                 case 'A': printf (_("Application\n")); break;
14555                 case 'R': printf (_("Realtime\n")); break;
14556                 case 'M': printf (_("Microcontroller\n")); break;
14557                 case 'S': printf (_("Application or Realtime\n")); break;
14558                 default: printf ("??? (%d)\n", val); break;
14559                 }
14560               break;
14561
14562             case 24: /* Tag_align_needed.  */
14563               val = read_uleb128 (p, &len, end);
14564               p += len;
14565               switch (val)
14566                 {
14567                 case 0: printf (_("None\n")); break;
14568                 case 1: printf (_("8-byte\n")); break;
14569                 case 2: printf (_("4-byte\n")); break;
14570                 case 3: printf ("??? 3\n"); break;
14571                 default:
14572                   if (val <= 12)
14573                     printf (_("8-byte and up to %d-byte extended\n"),
14574                             1 << val);
14575                   else
14576                     printf ("??? (%d)\n", val);
14577                   break;
14578                 }
14579               break;
14580
14581             case 25: /* Tag_align_preserved.  */
14582               val = read_uleb128 (p, &len, end);
14583               p += len;
14584               switch (val)
14585                 {
14586                 case 0: printf (_("None\n")); break;
14587                 case 1: printf (_("8-byte, except leaf SP\n")); break;
14588                 case 2: printf (_("8-byte\n")); break;
14589                 case 3: printf ("??? 3\n"); break;
14590                 default:
14591                   if (val <= 12)
14592                     printf (_("8-byte and up to %d-byte extended\n"),
14593                             1 << val);
14594                   else
14595                     printf ("??? (%d)\n", val);
14596                   break;
14597                 }
14598               break;
14599
14600             case 32: /* Tag_compatibility.  */
14601               {
14602                 val = read_uleb128 (p, &len, end);
14603                 p += len;
14604                 printf (_("flag = %d, vendor = "), val);
14605                 if (p < end - 1)
14606                   {
14607                     size_t maxlen = (end - p) - 1;
14608
14609                     print_symbol ((int) maxlen, (const char *) p);
14610                     p += strnlen ((char *) p, maxlen) + 1;
14611                   }
14612                 else
14613                   {
14614                     printf (_("<corrupt>"));
14615                     p = (unsigned char *) end;
14616                   }
14617                 putchar ('\n');
14618               }
14619               break;
14620
14621             case 64: /* Tag_nodefaults.  */
14622               /* PR 17531: file: 001-505008-0.01.  */
14623               if (p < end)
14624                 p++;
14625               printf (_("True\n"));
14626               break;
14627
14628             case 65: /* Tag_also_compatible_with.  */
14629               val = read_uleb128 (p, &len, end);
14630               p += len;
14631               if (val == 6 /* Tag_CPU_arch.  */)
14632                 {
14633                   val = read_uleb128 (p, &len, end);
14634                   p += len;
14635                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14636                     printf ("??? (%d)\n", val);
14637                   else
14638                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14639                 }
14640               else
14641                 printf ("???\n");
14642               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
14643                 ;
14644               break;
14645
14646             default:
14647               printf (_("<unknown: %d>\n"), tag);
14648               break;
14649             }
14650           return p;
14651
14652         case 1:
14653           return display_tag_value (-1, p, end);
14654         case 2:
14655           return display_tag_value (0, p, end);
14656
14657         default:
14658           assert (attr->type & 0x80);
14659           val = read_uleb128 (p, &len, end);
14660           p += len;
14661           type = attr->type & 0x7f;
14662           if (val >= type)
14663             printf ("??? (%d)\n", val);
14664           else
14665             printf ("%s\n", attr->table[val]);
14666           return p;
14667         }
14668     }
14669
14670   return display_tag_value (tag, p, end);
14671 }
14672
14673 static unsigned char *
14674 display_gnu_attribute (unsigned char * p,
14675                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14676                        const unsigned char * const end)
14677 {
14678   int tag;
14679   unsigned int len;
14680   unsigned int val;
14681
14682   tag = read_uleb128 (p, &len, end);
14683   p += len;
14684
14685   /* Tag_compatibility is the only generic GNU attribute defined at
14686      present.  */
14687   if (tag == 32)
14688     {
14689       val = read_uleb128 (p, &len, end);
14690       p += len;
14691
14692       printf (_("flag = %d, vendor = "), val);
14693       if (p == end)
14694         {
14695           printf (_("<corrupt>\n"));
14696           warn (_("corrupt vendor attribute\n"));
14697         }
14698       else
14699         {
14700           if (p < end - 1)
14701             {
14702               size_t maxlen = (end - p) - 1;
14703
14704               print_symbol ((int) maxlen, (const char *) p);
14705               p += strnlen ((char *) p, maxlen) + 1;
14706             }
14707           else
14708             {
14709               printf (_("<corrupt>"));
14710               p = (unsigned char *) end;
14711             }
14712           putchar ('\n');
14713         }
14714       return p;
14715     }
14716
14717   if ((tag & 2) == 0 && display_proc_gnu_attribute)
14718     return display_proc_gnu_attribute (p, tag, end);
14719
14720   return display_tag_value (tag, p, end);
14721 }
14722
14723 static unsigned char *
14724 display_power_gnu_attribute (unsigned char * p,
14725                              unsigned int tag,
14726                              const unsigned char * const end)
14727 {
14728   unsigned int len;
14729   unsigned int val;
14730
14731   if (tag == Tag_GNU_Power_ABI_FP)
14732     {
14733       val = read_uleb128 (p, &len, end);
14734       p += len;
14735       printf ("  Tag_GNU_Power_ABI_FP: ");
14736       if (len == 0)
14737         {
14738           printf (_("<corrupt>\n"));
14739           return p;
14740         }
14741
14742       if (val > 15)
14743         printf ("(%#x), ", val);
14744
14745       switch (val & 3)
14746         {
14747         case 0:
14748           printf (_("unspecified hard/soft float, "));
14749           break;
14750         case 1:
14751           printf (_("hard float, "));
14752           break;
14753         case 2:
14754           printf (_("soft float, "));
14755           break;
14756         case 3:
14757           printf (_("single-precision hard float, "));
14758           break;
14759         }
14760
14761       switch (val & 0xC)
14762         {
14763         case 0:
14764           printf (_("unspecified long double\n"));
14765           break;
14766         case 4:
14767           printf (_("128-bit IBM long double\n"));
14768           break;
14769         case 8:
14770           printf (_("64-bit long double\n"));
14771           break;
14772         case 12:
14773           printf (_("128-bit IEEE long double\n"));
14774           break;
14775         }
14776       return p;
14777     }
14778
14779   if (tag == Tag_GNU_Power_ABI_Vector)
14780     {
14781       val = read_uleb128 (p, &len, end);
14782       p += len;
14783       printf ("  Tag_GNU_Power_ABI_Vector: ");
14784       if (len == 0)
14785         {
14786           printf (_("<corrupt>\n"));
14787           return p;
14788         }
14789
14790       if (val > 3)
14791         printf ("(%#x), ", val);
14792
14793       switch (val & 3)
14794         {
14795         case 0:
14796           printf (_("unspecified\n"));
14797           break;
14798         case 1:
14799           printf (_("generic\n"));
14800           break;
14801         case 2:
14802           printf ("AltiVec\n");
14803           break;
14804         case 3:
14805           printf ("SPE\n");
14806           break;
14807         }
14808       return p;
14809     }
14810
14811   if (tag == Tag_GNU_Power_ABI_Struct_Return)
14812     {
14813       val = read_uleb128 (p, &len, end);
14814       p += len;
14815       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
14816       if (len == 0)
14817         {
14818           printf (_("<corrupt>\n"));
14819           return p;
14820         }
14821
14822       if (val > 2)
14823         printf ("(%#x), ", val);
14824
14825       switch (val & 3)
14826         {
14827         case 0:
14828           printf (_("unspecified\n"));
14829           break;
14830         case 1:
14831           printf ("r3/r4\n");
14832           break;
14833         case 2:
14834           printf (_("memory\n"));
14835           break;
14836         case 3:
14837           printf ("???\n");
14838           break;
14839         }
14840       return p;
14841     }
14842
14843   return display_tag_value (tag & 1, p, end);
14844 }
14845
14846 static unsigned char *
14847 display_s390_gnu_attribute (unsigned char * p,
14848                             unsigned int tag,
14849                             const unsigned char * const end)
14850 {
14851   unsigned int len;
14852   int val;
14853
14854   if (tag == Tag_GNU_S390_ABI_Vector)
14855     {
14856       val = read_uleb128 (p, &len, end);
14857       p += len;
14858       printf ("  Tag_GNU_S390_ABI_Vector: ");
14859
14860       switch (val)
14861         {
14862         case 0:
14863           printf (_("any\n"));
14864           break;
14865         case 1:
14866           printf (_("software\n"));
14867           break;
14868         case 2:
14869           printf (_("hardware\n"));
14870           break;
14871         default:
14872           printf ("??? (%d)\n", val);
14873           break;
14874         }
14875       return p;
14876    }
14877
14878   return display_tag_value (tag & 1, p, end);
14879 }
14880
14881 static void
14882 display_sparc_hwcaps (unsigned int mask)
14883 {
14884   if (mask)
14885     {
14886       bfd_boolean first = TRUE;
14887
14888       if (mask & ELF_SPARC_HWCAP_MUL32)
14889         fputs ("mul32", stdout), first = FALSE;
14890       if (mask & ELF_SPARC_HWCAP_DIV32)
14891         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14892       if (mask & ELF_SPARC_HWCAP_FSMULD)
14893         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14894       if (mask & ELF_SPARC_HWCAP_V8PLUS)
14895         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14896       if (mask & ELF_SPARC_HWCAP_POPC)
14897         printf ("%spopc", first ? "" : "|"), first = FALSE;
14898       if (mask & ELF_SPARC_HWCAP_VIS)
14899         printf ("%svis", first ? "" : "|"), first = FALSE;
14900       if (mask & ELF_SPARC_HWCAP_VIS2)
14901         printf ("%svis2", first ? "" : "|"), first = FALSE;
14902       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14903         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14904       if (mask & ELF_SPARC_HWCAP_FMAF)
14905         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14906       if (mask & ELF_SPARC_HWCAP_VIS3)
14907         printf ("%svis3", first ? "" : "|"), first = FALSE;
14908       if (mask & ELF_SPARC_HWCAP_HPC)
14909         printf ("%shpc", first ? "" : "|"), first = FALSE;
14910       if (mask & ELF_SPARC_HWCAP_RANDOM)
14911         printf ("%srandom", first ? "" : "|"), first = FALSE;
14912       if (mask & ELF_SPARC_HWCAP_TRANS)
14913         printf ("%strans", first ? "" : "|"), first = FALSE;
14914       if (mask & ELF_SPARC_HWCAP_FJFMAU)
14915         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14916       if (mask & ELF_SPARC_HWCAP_IMA)
14917         printf ("%sima", first ? "" : "|"), first = FALSE;
14918       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14919         printf ("%scspare", first ? "" : "|"), first = FALSE;
14920     }
14921   else
14922     fputc ('0', stdout);
14923   fputc ('\n', stdout);
14924 }
14925
14926 static void
14927 display_sparc_hwcaps2 (unsigned int mask)
14928 {
14929   if (mask)
14930     {
14931       bfd_boolean first = TRUE;
14932
14933       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14934         fputs ("fjathplus", stdout), first = FALSE;
14935       if (mask & ELF_SPARC_HWCAP2_VIS3B)
14936         printf ("%svis3b", first ? "" : "|"), first = FALSE;
14937       if (mask & ELF_SPARC_HWCAP2_ADP)
14938         printf ("%sadp", first ? "" : "|"), first = FALSE;
14939       if (mask & ELF_SPARC_HWCAP2_SPARC5)
14940         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14941       if (mask & ELF_SPARC_HWCAP2_MWAIT)
14942         printf ("%smwait", first ? "" : "|"), first = FALSE;
14943       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14944         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14945       if (mask & ELF_SPARC_HWCAP2_XMONT)
14946         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14947       if (mask & ELF_SPARC_HWCAP2_NSEC)
14948         printf ("%snsec", first ? "" : "|"), first = FALSE;
14949       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14950         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14951       if (mask & ELF_SPARC_HWCAP2_FJDES)
14952         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14953       if (mask & ELF_SPARC_HWCAP2_FJAES)
14954         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14955     }
14956   else
14957     fputc ('0', stdout);
14958   fputc ('\n', stdout);
14959 }
14960
14961 static unsigned char *
14962 display_sparc_gnu_attribute (unsigned char * p,
14963                              unsigned int tag,
14964                              const unsigned char * const end)
14965 {
14966   unsigned int len;
14967   int val;
14968
14969   if (tag == Tag_GNU_Sparc_HWCAPS)
14970     {
14971       val = read_uleb128 (p, &len, end);
14972       p += len;
14973       printf ("  Tag_GNU_Sparc_HWCAPS: ");
14974       display_sparc_hwcaps (val);
14975       return p;
14976     }
14977   if (tag == Tag_GNU_Sparc_HWCAPS2)
14978     {
14979       val = read_uleb128 (p, &len, end);
14980       p += len;
14981       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
14982       display_sparc_hwcaps2 (val);
14983       return p;
14984     }
14985
14986   return display_tag_value (tag, p, end);
14987 }
14988
14989 static void
14990 print_mips_fp_abi_value (unsigned int val)
14991 {
14992   switch (val)
14993     {
14994     case Val_GNU_MIPS_ABI_FP_ANY:
14995       printf (_("Hard or soft float\n"));
14996       break;
14997     case Val_GNU_MIPS_ABI_FP_DOUBLE:
14998       printf (_("Hard float (double precision)\n"));
14999       break;
15000     case Val_GNU_MIPS_ABI_FP_SINGLE:
15001       printf (_("Hard float (single precision)\n"));
15002       break;
15003     case Val_GNU_MIPS_ABI_FP_SOFT:
15004       printf (_("Soft float\n"));
15005       break;
15006     case Val_GNU_MIPS_ABI_FP_OLD_64:
15007       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15008       break;
15009     case Val_GNU_MIPS_ABI_FP_XX:
15010       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15011       break;
15012     case Val_GNU_MIPS_ABI_FP_64:
15013       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15014       break;
15015     case Val_GNU_MIPS_ABI_FP_64A:
15016       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15017       break;
15018     case Val_GNU_MIPS_ABI_FP_NAN2008:
15019       printf (_("NaN 2008 compatibility\n"));
15020       break;
15021     default:
15022       printf ("??? (%d)\n", val);
15023       break;
15024     }
15025 }
15026
15027 static unsigned char *
15028 display_mips_gnu_attribute (unsigned char * p,
15029                             unsigned int tag,
15030                             const unsigned char * const end)
15031 {
15032   if (tag == Tag_GNU_MIPS_ABI_FP)
15033     {
15034       unsigned int len;
15035       unsigned int val;
15036
15037       val = read_uleb128 (p, &len, end);
15038       p += len;
15039       printf ("  Tag_GNU_MIPS_ABI_FP: ");
15040
15041       print_mips_fp_abi_value (val);
15042
15043       return p;
15044    }
15045
15046   if (tag == Tag_GNU_MIPS_ABI_MSA)
15047     {
15048       unsigned int len;
15049       unsigned int val;
15050
15051       val = read_uleb128 (p, &len, end);
15052       p += len;
15053       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
15054
15055       switch (val)
15056         {
15057         case Val_GNU_MIPS_ABI_MSA_ANY:
15058           printf (_("Any MSA or not\n"));
15059           break;
15060         case Val_GNU_MIPS_ABI_MSA_128:
15061           printf (_("128-bit MSA\n"));
15062           break;
15063         default:
15064           printf ("??? (%d)\n", val);
15065           break;
15066         }
15067       return p;
15068     }
15069
15070   return display_tag_value (tag & 1, p, end);
15071 }
15072
15073 static unsigned char *
15074 display_tic6x_attribute (unsigned char * p,
15075                          const unsigned char * const end)
15076 {
15077   unsigned int tag;
15078   unsigned int len;
15079   int val;
15080
15081   tag = read_uleb128 (p, &len, end);
15082   p += len;
15083
15084   switch (tag)
15085     {
15086     case Tag_ISA:
15087       val = read_uleb128 (p, &len, end);
15088       p += len;
15089       printf ("  Tag_ISA: ");
15090
15091       switch (val)
15092         {
15093         case C6XABI_Tag_ISA_none:
15094           printf (_("None\n"));
15095           break;
15096         case C6XABI_Tag_ISA_C62X:
15097           printf ("C62x\n");
15098           break;
15099         case C6XABI_Tag_ISA_C67X:
15100           printf ("C67x\n");
15101           break;
15102         case C6XABI_Tag_ISA_C67XP:
15103           printf ("C67x+\n");
15104           break;
15105         case C6XABI_Tag_ISA_C64X:
15106           printf ("C64x\n");
15107           break;
15108         case C6XABI_Tag_ISA_C64XP:
15109           printf ("C64x+\n");
15110           break;
15111         case C6XABI_Tag_ISA_C674X:
15112           printf ("C674x\n");
15113           break;
15114         default:
15115           printf ("??? (%d)\n", val);
15116           break;
15117         }
15118       return p;
15119
15120     case Tag_ABI_wchar_t:
15121       val = read_uleb128 (p, &len, end);
15122       p += len;
15123       printf ("  Tag_ABI_wchar_t: ");
15124       switch (val)
15125         {
15126         case 0:
15127           printf (_("Not used\n"));
15128           break;
15129         case 1:
15130           printf (_("2 bytes\n"));
15131           break;
15132         case 2:
15133           printf (_("4 bytes\n"));
15134           break;
15135         default:
15136           printf ("??? (%d)\n", val);
15137           break;
15138         }
15139       return p;
15140
15141     case Tag_ABI_stack_align_needed:
15142       val = read_uleb128 (p, &len, end);
15143       p += len;
15144       printf ("  Tag_ABI_stack_align_needed: ");
15145       switch (val)
15146         {
15147         case 0:
15148           printf (_("8-byte\n"));
15149           break;
15150         case 1:
15151           printf (_("16-byte\n"));
15152           break;
15153         default:
15154           printf ("??? (%d)\n", val);
15155           break;
15156         }
15157       return p;
15158
15159     case Tag_ABI_stack_align_preserved:
15160       val = read_uleb128 (p, &len, end);
15161       p += len;
15162       printf ("  Tag_ABI_stack_align_preserved: ");
15163       switch (val)
15164         {
15165         case 0:
15166           printf (_("8-byte\n"));
15167           break;
15168         case 1:
15169           printf (_("16-byte\n"));
15170           break;
15171         default:
15172           printf ("??? (%d)\n", val);
15173           break;
15174         }
15175       return p;
15176
15177     case Tag_ABI_DSBT:
15178       val = read_uleb128 (p, &len, end);
15179       p += len;
15180       printf ("  Tag_ABI_DSBT: ");
15181       switch (val)
15182         {
15183         case 0:
15184           printf (_("DSBT addressing not used\n"));
15185           break;
15186         case 1:
15187           printf (_("DSBT addressing used\n"));
15188           break;
15189         default:
15190           printf ("??? (%d)\n", val);
15191           break;
15192         }
15193       return p;
15194
15195     case Tag_ABI_PID:
15196       val = read_uleb128 (p, &len, end);
15197       p += len;
15198       printf ("  Tag_ABI_PID: ");
15199       switch (val)
15200         {
15201         case 0:
15202           printf (_("Data addressing position-dependent\n"));
15203           break;
15204         case 1:
15205           printf (_("Data addressing position-independent, GOT near DP\n"));
15206           break;
15207         case 2:
15208           printf (_("Data addressing position-independent, GOT far from DP\n"));
15209           break;
15210         default:
15211           printf ("??? (%d)\n", val);
15212           break;
15213         }
15214       return p;
15215
15216     case Tag_ABI_PIC:
15217       val = read_uleb128 (p, &len, end);
15218       p += len;
15219       printf ("  Tag_ABI_PIC: ");
15220       switch (val)
15221         {
15222         case 0:
15223           printf (_("Code addressing position-dependent\n"));
15224           break;
15225         case 1:
15226           printf (_("Code addressing position-independent\n"));
15227           break;
15228         default:
15229           printf ("??? (%d)\n", val);
15230           break;
15231         }
15232       return p;
15233
15234     case Tag_ABI_array_object_alignment:
15235       val = read_uleb128 (p, &len, end);
15236       p += len;
15237       printf ("  Tag_ABI_array_object_alignment: ");
15238       switch (val)
15239         {
15240         case 0:
15241           printf (_("8-byte\n"));
15242           break;
15243         case 1:
15244           printf (_("4-byte\n"));
15245           break;
15246         case 2:
15247           printf (_("16-byte\n"));
15248           break;
15249         default:
15250           printf ("??? (%d)\n", val);
15251           break;
15252         }
15253       return p;
15254
15255     case Tag_ABI_array_object_align_expected:
15256       val = read_uleb128 (p, &len, end);
15257       p += len;
15258       printf ("  Tag_ABI_array_object_align_expected: ");
15259       switch (val)
15260         {
15261         case 0:
15262           printf (_("8-byte\n"));
15263           break;
15264         case 1:
15265           printf (_("4-byte\n"));
15266           break;
15267         case 2:
15268           printf (_("16-byte\n"));
15269           break;
15270         default:
15271           printf ("??? (%d)\n", val);
15272           break;
15273         }
15274       return p;
15275
15276     case Tag_ABI_compatibility:
15277       {
15278         val = read_uleb128 (p, &len, end);
15279         p += len;
15280         printf ("  Tag_ABI_compatibility: ");
15281         printf (_("flag = %d, vendor = "), val);
15282         if (p < end - 1)
15283           {
15284             size_t maxlen = (end - p) - 1;
15285
15286             print_symbol ((int) maxlen, (const char *) p);
15287             p += strnlen ((char *) p, maxlen) + 1;
15288           }
15289         else
15290           {
15291             printf (_("<corrupt>"));
15292             p = (unsigned char *) end;
15293           }
15294         putchar ('\n');
15295         return p;
15296       }
15297
15298     case Tag_ABI_conformance:
15299       {
15300         printf ("  Tag_ABI_conformance: \"");
15301         if (p < end - 1)
15302           {
15303             size_t maxlen = (end - p) - 1;
15304
15305             print_symbol ((int) maxlen, (const char *) p);
15306             p += strnlen ((char *) p, maxlen) + 1;
15307           }
15308         else
15309           {
15310             printf (_("<corrupt>"));
15311             p = (unsigned char *) end;
15312           }
15313         printf ("\"\n");
15314         return p;
15315       }
15316     }
15317
15318   return display_tag_value (tag, p, end);
15319 }
15320
15321 static void
15322 display_raw_attribute (unsigned char * p, unsigned char const * const end)
15323 {
15324   unsigned long addr = 0;
15325   size_t bytes = end - p;
15326
15327   assert (end >= p);
15328   while (bytes)
15329     {
15330       int j;
15331       int k;
15332       int lbytes = (bytes > 16 ? 16 : bytes);
15333
15334       printf ("  0x%8.8lx ", addr);
15335
15336       for (j = 0; j < 16; j++)
15337         {
15338           if (j < lbytes)
15339             printf ("%2.2x", p[j]);
15340           else
15341             printf ("  ");
15342
15343           if ((j & 3) == 3)
15344             printf (" ");
15345         }
15346
15347       for (j = 0; j < lbytes; j++)
15348         {
15349           k = p[j];
15350           if (k >= ' ' && k < 0x7f)
15351             printf ("%c", k);
15352           else
15353             printf (".");
15354         }
15355
15356       putchar ('\n');
15357
15358       p  += lbytes;
15359       bytes -= lbytes;
15360       addr += lbytes;
15361     }
15362
15363   putchar ('\n');
15364 }
15365
15366 static unsigned char *
15367 display_msp430x_attribute (unsigned char * p,
15368                            const unsigned char * const end)
15369 {
15370   unsigned int len;
15371   unsigned int val;
15372   unsigned int tag;
15373
15374   tag = read_uleb128 (p, & len, end);
15375   p += len;
15376
15377   switch (tag)
15378     {
15379     case OFBA_MSPABI_Tag_ISA:
15380       val = read_uleb128 (p, &len, end);
15381       p += len;
15382       printf ("  Tag_ISA: ");
15383       switch (val)
15384         {
15385         case 0: printf (_("None\n")); break;
15386         case 1: printf (_("MSP430\n")); break;
15387         case 2: printf (_("MSP430X\n")); break;
15388         default: printf ("??? (%d)\n", val); break;
15389         }
15390       break;
15391
15392     case OFBA_MSPABI_Tag_Code_Model:
15393       val = read_uleb128 (p, &len, end);
15394       p += len;
15395       printf ("  Tag_Code_Model: ");
15396       switch (val)
15397         {
15398         case 0: printf (_("None\n")); break;
15399         case 1: printf (_("Small\n")); break;
15400         case 2: printf (_("Large\n")); break;
15401         default: printf ("??? (%d)\n", val); break;
15402         }
15403       break;
15404
15405     case OFBA_MSPABI_Tag_Data_Model:
15406       val = read_uleb128 (p, &len, end);
15407       p += len;
15408       printf ("  Tag_Data_Model: ");
15409       switch (val)
15410         {
15411         case 0: printf (_("None\n")); break;
15412         case 1: printf (_("Small\n")); break;
15413         case 2: printf (_("Large\n")); break;
15414         case 3: printf (_("Restricted Large\n")); break;
15415         default: printf ("??? (%d)\n", val); break;
15416         }
15417       break;
15418
15419     default:
15420       printf (_("  <unknown tag %d>: "), tag);
15421
15422       if (tag & 1)
15423         {
15424           putchar ('"');
15425           if (p < end - 1)
15426             {
15427               size_t maxlen = (end - p) - 1;
15428
15429               print_symbol ((int) maxlen, (const char *) p);
15430               p += strnlen ((char *) p, maxlen) + 1;
15431             }
15432           else
15433             {
15434               printf (_("<corrupt>"));
15435               p = (unsigned char *) end;
15436             }
15437           printf ("\"\n");
15438         }
15439       else
15440         {
15441           val = read_uleb128 (p, &len, end);
15442           p += len;
15443           printf ("%d (0x%x)\n", val, val);
15444         }
15445       break;
15446    }
15447
15448   assert (p <= end);
15449   return p;
15450 }
15451
15452 struct riscv_attr_tag_t {
15453   const char *name;
15454   int tag;
15455 };
15456
15457 static struct riscv_attr_tag_t riscv_attr_tag[] =
15458 {
15459 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
15460   T(arch),
15461   T(priv_spec),
15462   T(priv_spec_minor),
15463   T(priv_spec_revision),
15464   T(unaligned_access),
15465   T(stack_align),
15466 #undef T
15467 };
15468
15469 static unsigned char *
15470 display_riscv_attribute (unsigned char *p,
15471                          const unsigned char * const end)
15472 {
15473   unsigned int len;
15474   int val;
15475   int tag;
15476   struct riscv_attr_tag_t *attr = NULL;
15477   unsigned i;
15478
15479   tag = read_uleb128 (p, &len, end);
15480   p += len;
15481
15482   /* Find the name of attribute. */
15483   for (i = 0; i < ARRAY_SIZE (riscv_attr_tag); i++)
15484     {
15485       if (riscv_attr_tag[i].tag == tag)
15486         {
15487           attr = &riscv_attr_tag[i];
15488           break;
15489         }
15490     }
15491
15492   if (attr)
15493     printf ("  %s: ", attr->name);
15494   else
15495     return display_tag_value (tag, p, end);
15496
15497   switch (tag)
15498     {
15499     case Tag_RISCV_priv_spec:
15500     case Tag_RISCV_priv_spec_minor:
15501     case Tag_RISCV_priv_spec_revision:
15502       val = read_uleb128 (p, &len, end);
15503       p += len;
15504       printf (_("%d\n"), val);
15505       break;
15506     case Tag_RISCV_unaligned_access:
15507       val = read_uleb128 (p, &len, end);
15508       p += len;
15509       switch (val)
15510         {
15511         case 0:
15512           printf (_("No unaligned access\n"));
15513           break;
15514         case 1:
15515           printf (_("Unaligned access\n"));
15516           break;
15517         }
15518       break;
15519     case Tag_RISCV_stack_align:
15520       val = read_uleb128 (p, &len, end);
15521       p += len;
15522       printf (_("%d-bytes\n"), val);
15523       break;
15524     case Tag_RISCV_arch:
15525       p = display_tag_value (-1, p, end);
15526       break;
15527     default:
15528       return display_tag_value (tag, p, end);
15529     }
15530
15531   return p;
15532 }
15533
15534 static bfd_boolean
15535 process_attributes (Filedata * filedata,
15536                     const char * public_name,
15537                     unsigned int proc_type,
15538                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15539                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15540 {
15541   Elf_Internal_Shdr * sect;
15542   unsigned i;
15543   bfd_boolean res = TRUE;
15544
15545   /* Find the section header so that we get the size.  */
15546   for (i = 0, sect = filedata->section_headers;
15547        i < filedata->file_header.e_shnum;
15548        i++, sect++)
15549     {
15550       unsigned char * contents;
15551       unsigned char * p;
15552
15553       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15554         continue;
15555
15556       contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15557                                              sect->sh_size, _("attributes"));
15558       if (contents == NULL)
15559         {
15560           res = FALSE;
15561           continue;
15562         }
15563
15564       p = contents;
15565       /* The first character is the version of the attributes.
15566          Currently only version 1, (aka 'A') is recognised here.  */
15567       if (*p != 'A')
15568         {
15569           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15570           res = FALSE;
15571         }
15572       else
15573         {
15574           bfd_vma section_len;
15575
15576           section_len = sect->sh_size - 1;
15577           p++;
15578
15579           while (section_len > 0)
15580             {
15581               bfd_vma attr_len;
15582               unsigned int namelen;
15583               bfd_boolean public_section;
15584               bfd_boolean gnu_section;
15585
15586               if (section_len <= 4)
15587                 {
15588                   error (_("Tag section ends prematurely\n"));
15589                   res = FALSE;
15590                   break;
15591                 }
15592               attr_len = byte_get (p, 4);
15593               p += 4;
15594
15595               if (attr_len > section_len)
15596                 {
15597                   error (_("Bad attribute length (%u > %u)\n"),
15598                           (unsigned) attr_len, (unsigned) section_len);
15599                   attr_len = section_len;
15600                   res = FALSE;
15601                 }
15602               /* PR 17531: file: 001-101425-0.004  */
15603               else if (attr_len < 5)
15604                 {
15605                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
15606                   res = FALSE;
15607                   break;
15608                 }
15609
15610               section_len -= attr_len;
15611               attr_len -= 4;
15612
15613               namelen = strnlen ((char *) p, attr_len) + 1;
15614               if (namelen == 0 || namelen >= attr_len)
15615                 {
15616                   error (_("Corrupt attribute section name\n"));
15617                   res = FALSE;
15618                   break;
15619                 }
15620
15621               printf (_("Attribute Section: "));
15622               print_symbol (INT_MAX, (const char *) p);
15623               putchar ('\n');
15624
15625               if (public_name && streq ((char *) p, public_name))
15626                 public_section = TRUE;
15627               else
15628                 public_section = FALSE;
15629
15630               if (streq ((char *) p, "gnu"))
15631                 gnu_section = TRUE;
15632               else
15633                 gnu_section = FALSE;
15634
15635               p += namelen;
15636               attr_len -= namelen;
15637
15638               while (attr_len > 0 && p < contents + sect->sh_size)
15639                 {
15640                   int tag;
15641                   int val;
15642                   bfd_vma size;
15643                   unsigned char * end;
15644
15645                   /* PR binutils/17531: Safe handling of corrupt files.  */
15646                   if (attr_len < 6)
15647                     {
15648                       error (_("Unused bytes at end of section\n"));
15649                       res = FALSE;
15650                       section_len = 0;
15651                       break;
15652                     }
15653
15654                   tag = *(p++);
15655                   size = byte_get (p, 4);
15656                   if (size > attr_len)
15657                     {
15658                       error (_("Bad subsection length (%u > %u)\n"),
15659                               (unsigned) size, (unsigned) attr_len);
15660                       res = FALSE;
15661                       size = attr_len;
15662                     }
15663                   /* PR binutils/17531: Safe handling of corrupt files.  */
15664                   if (size < 6)
15665                     {
15666                       error (_("Bad subsection length (%u < 6)\n"),
15667                               (unsigned) size);
15668                       res = FALSE;
15669                       section_len = 0;
15670                       break;
15671                     }
15672
15673                   attr_len -= size;
15674                   end = p + size - 1;
15675                   assert (end <= contents + sect->sh_size);
15676                   p += 4;
15677
15678                   switch (tag)
15679                     {
15680                     case 1:
15681                       printf (_("File Attributes\n"));
15682                       break;
15683                     case 2:
15684                       printf (_("Section Attributes:"));
15685                       goto do_numlist;
15686                     case 3:
15687                       printf (_("Symbol Attributes:"));
15688                       /* Fall through.  */
15689                     do_numlist:
15690                       for (;;)
15691                         {
15692                           unsigned int j;
15693
15694                           val = read_uleb128 (p, &j, end);
15695                           p += j;
15696                           if (val == 0)
15697                             break;
15698                           printf (" %d", val);
15699                         }
15700                       printf ("\n");
15701                       break;
15702                     default:
15703                       printf (_("Unknown tag: %d\n"), tag);
15704                       public_section = FALSE;
15705                       break;
15706                     }
15707
15708                   if (public_section && display_pub_attribute != NULL)
15709                     {
15710                       while (p < end)
15711                         p = display_pub_attribute (p, end);
15712                       assert (p == end);
15713                     }
15714                   else if (gnu_section && display_proc_gnu_attribute != NULL)
15715                     {
15716                       while (p < end)
15717                         p = display_gnu_attribute (p,
15718                                                    display_proc_gnu_attribute,
15719                                                    end);
15720                       assert (p == end);
15721                     }
15722                   else if (p < end)
15723                     {
15724                       printf (_("  Unknown attribute:\n"));
15725                       display_raw_attribute (p, end);
15726                       p = end;
15727                     }
15728                   else
15729                     attr_len = 0;
15730                 }
15731             }
15732         }
15733
15734       free (contents);
15735     }
15736
15737   return res;
15738 }
15739
15740 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15741    Print the Address, Access and Initial fields of an entry at VMA ADDR
15742    and return the VMA of the next entry, or -1 if there was a problem.
15743    Does not read from DATA_END or beyond.  */
15744
15745 static bfd_vma
15746 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15747                       unsigned char * data_end)
15748 {
15749   printf ("  ");
15750   print_vma (addr, LONG_HEX);
15751   printf (" ");
15752   if (addr < pltgot + 0xfff0)
15753     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15754   else
15755     printf ("%10s", "");
15756   printf (" ");
15757   if (data == NULL)
15758     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15759   else
15760     {
15761       bfd_vma entry;
15762       unsigned char * from = data + addr - pltgot;
15763
15764       if (from + (is_32bit_elf ? 4 : 8) > data_end)
15765         {
15766           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15767           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15768           return (bfd_vma) -1;
15769         }
15770       else
15771         {
15772           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15773           print_vma (entry, LONG_HEX);
15774         }
15775     }
15776   return addr + (is_32bit_elf ? 4 : 8);
15777 }
15778
15779 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15780    PLTGOT.  Print the Address and Initial fields of an entry at VMA
15781    ADDR and return the VMA of the next entry.  */
15782
15783 static bfd_vma
15784 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15785 {
15786   printf ("  ");
15787   print_vma (addr, LONG_HEX);
15788   printf (" ");
15789   if (data == NULL)
15790     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15791   else
15792     {
15793       bfd_vma entry;
15794
15795       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15796       print_vma (entry, LONG_HEX);
15797     }
15798   return addr + (is_32bit_elf ? 4 : 8);
15799 }
15800
15801 static void
15802 print_mips_ases (unsigned int mask)
15803 {
15804   if (mask & AFL_ASE_DSP)
15805     fputs ("\n\tDSP ASE", stdout);
15806   if (mask & AFL_ASE_DSPR2)
15807     fputs ("\n\tDSP R2 ASE", stdout);
15808   if (mask & AFL_ASE_DSPR3)
15809     fputs ("\n\tDSP R3 ASE", stdout);
15810   if (mask & AFL_ASE_EVA)
15811     fputs ("\n\tEnhanced VA Scheme", stdout);
15812   if (mask & AFL_ASE_MCU)
15813     fputs ("\n\tMCU (MicroController) ASE", stdout);
15814   if (mask & AFL_ASE_MDMX)
15815     fputs ("\n\tMDMX ASE", stdout);
15816   if (mask & AFL_ASE_MIPS3D)
15817     fputs ("\n\tMIPS-3D ASE", stdout);
15818   if (mask & AFL_ASE_MT)
15819     fputs ("\n\tMT ASE", stdout);
15820   if (mask & AFL_ASE_SMARTMIPS)
15821     fputs ("\n\tSmartMIPS ASE", stdout);
15822   if (mask & AFL_ASE_VIRT)
15823     fputs ("\n\tVZ ASE", stdout);
15824   if (mask & AFL_ASE_MSA)
15825     fputs ("\n\tMSA ASE", stdout);
15826   if (mask & AFL_ASE_MIPS16)
15827     fputs ("\n\tMIPS16 ASE", stdout);
15828   if (mask & AFL_ASE_MICROMIPS)
15829     fputs ("\n\tMICROMIPS ASE", stdout);
15830   if (mask & AFL_ASE_XPA)
15831     fputs ("\n\tXPA ASE", stdout);
15832   if (mask & AFL_ASE_MIPS16E2)
15833     fputs ("\n\tMIPS16e2 ASE", stdout);
15834   if (mask & AFL_ASE_CRC)
15835     fputs ("\n\tCRC ASE", stdout);
15836   if (mask & AFL_ASE_GINV)
15837     fputs ("\n\tGINV ASE", stdout);
15838   if (mask & AFL_ASE_LOONGSON_MMI)
15839     fputs ("\n\tLoongson MMI ASE", stdout);
15840   if (mask & AFL_ASE_LOONGSON_CAM)
15841     fputs ("\n\tLoongson CAM ASE", stdout);
15842   if (mask & AFL_ASE_LOONGSON_EXT)
15843     fputs ("\n\tLoongson EXT ASE", stdout);
15844   if (mask & AFL_ASE_LOONGSON_EXT2)
15845     fputs ("\n\tLoongson EXT2 ASE", stdout);
15846   if (mask == 0)
15847     fprintf (stdout, "\n\t%s", _("None"));
15848   else if ((mask & ~AFL_ASE_MASK) != 0)
15849     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15850 }
15851
15852 static void
15853 print_mips_isa_ext (unsigned int isa_ext)
15854 {
15855   switch (isa_ext)
15856     {
15857     case 0:
15858       fputs (_("None"), stdout);
15859       break;
15860     case AFL_EXT_XLR:
15861       fputs ("RMI XLR", stdout);
15862       break;
15863     case AFL_EXT_OCTEON3:
15864       fputs ("Cavium Networks Octeon3", stdout);
15865       break;
15866     case AFL_EXT_OCTEON2:
15867       fputs ("Cavium Networks Octeon2", stdout);
15868       break;
15869     case AFL_EXT_OCTEONP:
15870       fputs ("Cavium Networks OcteonP", stdout);
15871       break;
15872     case AFL_EXT_OCTEON:
15873       fputs ("Cavium Networks Octeon", stdout);
15874       break;
15875     case AFL_EXT_5900:
15876       fputs ("Toshiba R5900", stdout);
15877       break;
15878     case AFL_EXT_4650:
15879       fputs ("MIPS R4650", stdout);
15880       break;
15881     case AFL_EXT_4010:
15882       fputs ("LSI R4010", stdout);
15883       break;
15884     case AFL_EXT_4100:
15885       fputs ("NEC VR4100", stdout);
15886       break;
15887     case AFL_EXT_3900:
15888       fputs ("Toshiba R3900", stdout);
15889       break;
15890     case AFL_EXT_10000:
15891       fputs ("MIPS R10000", stdout);
15892       break;
15893     case AFL_EXT_SB1:
15894       fputs ("Broadcom SB-1", stdout);
15895       break;
15896     case AFL_EXT_4111:
15897       fputs ("NEC VR4111/VR4181", stdout);
15898       break;
15899     case AFL_EXT_4120:
15900       fputs ("NEC VR4120", stdout);
15901       break;
15902     case AFL_EXT_5400:
15903       fputs ("NEC VR5400", stdout);
15904       break;
15905     case AFL_EXT_5500:
15906       fputs ("NEC VR5500", stdout);
15907       break;
15908     case AFL_EXT_LOONGSON_2E:
15909       fputs ("ST Microelectronics Loongson 2E", stdout);
15910       break;
15911     case AFL_EXT_LOONGSON_2F:
15912       fputs ("ST Microelectronics Loongson 2F", stdout);
15913       break;
15914     case AFL_EXT_INTERAPTIV_MR2:
15915       fputs ("Imagination interAptiv MR2", stdout);
15916       break;
15917     default:
15918       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15919     }
15920 }
15921
15922 static signed int
15923 get_mips_reg_size (int reg_size)
15924 {
15925   return (reg_size == AFL_REG_NONE) ? 0
15926          : (reg_size == AFL_REG_32) ? 32
15927          : (reg_size == AFL_REG_64) ? 64
15928          : (reg_size == AFL_REG_128) ? 128
15929          : -1;
15930 }
15931
15932 static bfd_boolean
15933 process_mips_specific (Filedata * filedata)
15934 {
15935   Elf_Internal_Dyn * entry;
15936   Elf_Internal_Shdr *sect = NULL;
15937   size_t liblist_offset = 0;
15938   size_t liblistno = 0;
15939   size_t conflictsno = 0;
15940   size_t options_offset = 0;
15941   size_t conflicts_offset = 0;
15942   size_t pltrelsz = 0;
15943   size_t pltrel = 0;
15944   bfd_vma pltgot = 0;
15945   bfd_vma mips_pltgot = 0;
15946   bfd_vma jmprel = 0;
15947   bfd_vma local_gotno = 0;
15948   bfd_vma gotsym = 0;
15949   bfd_vma symtabno = 0;
15950   bfd_boolean res = TRUE;
15951
15952   if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
15953                             display_mips_gnu_attribute))
15954     res = FALSE;
15955
15956   sect = find_section (filedata, ".MIPS.abiflags");
15957
15958   if (sect != NULL)
15959     {
15960       Elf_External_ABIFlags_v0 *abiflags_ext;
15961       Elf_Internal_ABIFlags_v0 abiflags_in;
15962
15963       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15964         {
15965           error (_("Corrupt MIPS ABI Flags section.\n"));
15966           res = FALSE;
15967         }
15968       else
15969         {
15970           abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
15971                                    sect->sh_size, _("MIPS ABI Flags section"));
15972           if (abiflags_ext)
15973             {
15974               abiflags_in.version = BYTE_GET (abiflags_ext->version);
15975               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15976               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15977               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15978               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15979               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15980               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15981               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15982               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15983               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15984               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15985
15986               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15987               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15988               if (abiflags_in.isa_rev > 1)
15989                 printf ("r%d", abiflags_in.isa_rev);
15990               printf ("\nGPR size: %d",
15991                       get_mips_reg_size (abiflags_in.gpr_size));
15992               printf ("\nCPR1 size: %d",
15993                       get_mips_reg_size (abiflags_in.cpr1_size));
15994               printf ("\nCPR2 size: %d",
15995                       get_mips_reg_size (abiflags_in.cpr2_size));
15996               fputs ("\nFP ABI: ", stdout);
15997               print_mips_fp_abi_value (abiflags_in.fp_abi);
15998               fputs ("ISA Extension: ", stdout);
15999               print_mips_isa_ext (abiflags_in.isa_ext);
16000               fputs ("\nASEs:", stdout);
16001               print_mips_ases (abiflags_in.ases);
16002               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
16003               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
16004               fputc ('\n', stdout);
16005               free (abiflags_ext);
16006             }
16007         }
16008     }
16009
16010   /* We have a lot of special sections.  Thanks SGI!  */
16011   if (dynamic_section == NULL)
16012     {
16013       /* No dynamic information available.  See if there is static GOT.  */
16014       sect = find_section (filedata, ".got");
16015       if (sect != NULL)
16016         {
16017           unsigned char *data_end;
16018           unsigned char *data;
16019           bfd_vma ent, end;
16020           int addr_size;
16021
16022           pltgot = sect->sh_addr;
16023
16024           ent = pltgot;
16025           addr_size = (is_32bit_elf ? 4 : 8);
16026           end = pltgot + sect->sh_size;
16027
16028           data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
16029                                              end - pltgot, 1,
16030                                              _("Global Offset Table data"));
16031           /* PR 12855: Null data is handled gracefully throughout.  */
16032           data_end = data + (end - pltgot);
16033
16034           printf (_("\nStatic GOT:\n"));
16035           printf (_(" Canonical gp value: "));
16036           print_vma (ent + 0x7ff0, LONG_HEX);
16037           printf ("\n\n");
16038
16039           /* In a dynamic binary GOT[0] is reserved for the dynamic
16040              loader to store the lazy resolver pointer, however in
16041              a static binary it may well have been omitted and GOT
16042              reduced to a table of addresses.
16043              PR 21344: Check for the entry being fully available
16044              before fetching it.  */
16045           if (data
16046               && data + ent - pltgot + addr_size <= data_end
16047               && byte_get (data + ent - pltgot, addr_size) == 0)
16048             {
16049               printf (_(" Reserved entries:\n"));
16050               printf (_("  %*s %10s %*s\n"),
16051                       addr_size * 2, _("Address"), _("Access"),
16052                       addr_size * 2, _("Value"));
16053               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16054               printf ("\n");
16055               if (ent == (bfd_vma) -1)
16056                 goto sgot_print_fail;
16057
16058               /* Check for the MSB of GOT[1] being set, identifying a
16059                  GNU object.  This entry will be used by some runtime
16060                  loaders, to store the module pointer.  Otherwise this
16061                  is an ordinary local entry.
16062                  PR 21344: Check for the entry being fully available
16063                  before fetching it.  */
16064               if (data
16065                   && data + ent - pltgot + addr_size <= data_end
16066                   && (byte_get (data + ent - pltgot, addr_size)
16067                       >> (addr_size * 8 - 1)) != 0)
16068                 {
16069                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
16070                   printf ("\n");
16071                   if (ent == (bfd_vma) -1)
16072                     goto sgot_print_fail;
16073                 }
16074               printf ("\n");
16075             }
16076
16077           if (data != NULL && ent < end)
16078             {
16079               printf (_(" Local entries:\n"));
16080               printf ("  %*s %10s %*s\n",
16081                       addr_size * 2, _("Address"), _("Access"),
16082                       addr_size * 2, _("Value"));
16083               while (ent < end)
16084                 {
16085                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
16086                   printf ("\n");
16087                   if (ent == (bfd_vma) -1)
16088                     goto sgot_print_fail;
16089                 }
16090               printf ("\n");
16091             }
16092
16093         sgot_print_fail:
16094           if (data)
16095             free (data);
16096         }
16097       return res;
16098     }
16099
16100   for (entry = dynamic_section;
16101        /* PR 17531 file: 012-50589-0.004.  */
16102        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
16103        ++entry)
16104     switch (entry->d_tag)
16105       {
16106       case DT_MIPS_LIBLIST:
16107         liblist_offset
16108           = offset_from_vma (filedata, entry->d_un.d_val,
16109                              liblistno * sizeof (Elf32_External_Lib));
16110         break;
16111       case DT_MIPS_LIBLISTNO:
16112         liblistno = entry->d_un.d_val;
16113         break;
16114       case DT_MIPS_OPTIONS:
16115         options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
16116         break;
16117       case DT_MIPS_CONFLICT:
16118         conflicts_offset
16119           = offset_from_vma (filedata, entry->d_un.d_val,
16120                              conflictsno * sizeof (Elf32_External_Conflict));
16121         break;
16122       case DT_MIPS_CONFLICTNO:
16123         conflictsno = entry->d_un.d_val;
16124         break;
16125       case DT_PLTGOT:
16126         pltgot = entry->d_un.d_ptr;
16127         break;
16128       case DT_MIPS_LOCAL_GOTNO:
16129         local_gotno = entry->d_un.d_val;
16130         break;
16131       case DT_MIPS_GOTSYM:
16132         gotsym = entry->d_un.d_val;
16133         break;
16134       case DT_MIPS_SYMTABNO:
16135         symtabno = entry->d_un.d_val;
16136         break;
16137       case DT_MIPS_PLTGOT:
16138         mips_pltgot = entry->d_un.d_ptr;
16139         break;
16140       case DT_PLTREL:
16141         pltrel = entry->d_un.d_val;
16142         break;
16143       case DT_PLTRELSZ:
16144         pltrelsz = entry->d_un.d_val;
16145         break;
16146       case DT_JMPREL:
16147         jmprel = entry->d_un.d_ptr;
16148         break;
16149       default:
16150         break;
16151       }
16152
16153   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
16154     {
16155       Elf32_External_Lib * elib;
16156       size_t cnt;
16157
16158       elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
16159                                               liblistno,
16160                                               sizeof (Elf32_External_Lib),
16161                                               _("liblist section data"));
16162       if (elib)
16163         {
16164           printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16165                             "\nSection '.liblist' contains %lu entries:\n",
16166                             (unsigned long) liblistno),
16167                   (unsigned long) liblistno);
16168           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
16169                  stdout);
16170
16171           for (cnt = 0; cnt < liblistno; ++cnt)
16172             {
16173               Elf32_Lib liblist;
16174               time_t atime;
16175               char timebuf[128];
16176               struct tm * tmp;
16177
16178               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16179               atime = BYTE_GET (elib[cnt].l_time_stamp);
16180               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16181               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16182               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16183
16184               tmp = gmtime (&atime);
16185               snprintf (timebuf, sizeof (timebuf),
16186                         "%04u-%02u-%02uT%02u:%02u:%02u",
16187                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16188                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16189
16190               printf ("%3lu: ", (unsigned long) cnt);
16191               if (VALID_DYNAMIC_NAME (liblist.l_name))
16192                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
16193               else
16194                 printf (_("<corrupt: %9ld>"), liblist.l_name);
16195               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
16196                       liblist.l_version);
16197
16198               if (liblist.l_flags == 0)
16199                 puts (_(" NONE"));
16200               else
16201                 {
16202                   static const struct
16203                   {
16204                     const char * name;
16205                     int bit;
16206                   }
16207                   l_flags_vals[] =
16208                   {
16209                     { " EXACT_MATCH", LL_EXACT_MATCH },
16210                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
16211                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
16212                     { " EXPORTS", LL_EXPORTS },
16213                     { " DELAY_LOAD", LL_DELAY_LOAD },
16214                     { " DELTA", LL_DELTA }
16215                   };
16216                   int flags = liblist.l_flags;
16217                   size_t fcnt;
16218
16219                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
16220                     if ((flags & l_flags_vals[fcnt].bit) != 0)
16221                       {
16222                         fputs (l_flags_vals[fcnt].name, stdout);
16223                         flags ^= l_flags_vals[fcnt].bit;
16224                       }
16225                   if (flags != 0)
16226                     printf (" %#x", (unsigned int) flags);
16227
16228                   puts ("");
16229                 }
16230             }
16231
16232           free (elib);
16233         }
16234       else
16235         res = FALSE;
16236     }
16237
16238   if (options_offset != 0)
16239     {
16240       Elf_External_Options * eopt;
16241       Elf_Internal_Options * iopt;
16242       Elf_Internal_Options * option;
16243       size_t offset;
16244       int cnt;
16245       sect = filedata->section_headers;
16246
16247       /* Find the section header so that we get the size.  */
16248       sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
16249       /* PR 17533 file: 012-277276-0.004.  */
16250       if (sect == NULL)
16251         {
16252           error (_("No MIPS_OPTIONS header found\n"));
16253           return FALSE;
16254         }
16255       /* PR 24243  */
16256       if (sect->sh_size < sizeof (* eopt))
16257         {
16258           error (_("The MIPS options section is too small.\n"));
16259           return FALSE;
16260         }
16261
16262       eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
16263                                                 sect->sh_size, _("options"));
16264       if (eopt)
16265         {
16266           iopt = (Elf_Internal_Options *)
16267               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
16268           if (iopt == NULL)
16269             {
16270               error (_("Out of memory allocating space for MIPS options\n"));
16271               return FALSE;
16272             }
16273
16274           offset = cnt = 0;
16275           option = iopt;
16276
16277           while (offset <= sect->sh_size - sizeof (* eopt))
16278             {
16279               Elf_External_Options * eoption;
16280
16281               eoption = (Elf_External_Options *) ((char *) eopt + offset);
16282
16283               option->kind = BYTE_GET (eoption->kind);
16284               option->size = BYTE_GET (eoption->size);
16285               option->section = BYTE_GET (eoption->section);
16286               option->info = BYTE_GET (eoption->info);
16287
16288               /* PR 17531: file: ffa0fa3b.  */
16289               if (option->size < sizeof (* eopt)
16290                   || offset + option->size > sect->sh_size)
16291                 {
16292                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
16293                   return FALSE;
16294                 }
16295               offset += option->size;
16296
16297               ++option;
16298               ++cnt;
16299             }
16300
16301           printf (ngettext ("\nSection '%s' contains %d entry:\n",
16302                             "\nSection '%s' contains %d entries:\n",
16303                             cnt),
16304                   printable_section_name (filedata, sect), cnt);
16305
16306           option = iopt;
16307           offset = 0;
16308
16309           while (cnt-- > 0)
16310             {
16311               size_t len;
16312
16313               switch (option->kind)
16314                 {
16315                 case ODK_NULL:
16316                   /* This shouldn't happen.  */
16317                   printf (" NULL       %d %lx", option->section, option->info);
16318                   break;
16319                 case ODK_REGINFO:
16320                   printf (" REGINFO    ");
16321                   if (filedata->file_header.e_machine == EM_MIPS)
16322                     {
16323                       /* 32bit form.  */
16324                       Elf32_External_RegInfo * ereg;
16325                       Elf32_RegInfo reginfo;
16326
16327                       ereg = (Elf32_External_RegInfo *) (option + 1);
16328                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16329                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16330                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16331                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16332                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16333                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16334
16335                       printf ("GPR %08lx  GP 0x%lx\n",
16336                               reginfo.ri_gprmask,
16337                               (unsigned long) reginfo.ri_gp_value);
16338                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
16339                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16340                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16341                     }
16342                   else
16343                     {
16344                       /* 64 bit form.  */
16345                       Elf64_External_RegInfo * ereg;
16346                       Elf64_Internal_RegInfo reginfo;
16347
16348                       ereg = (Elf64_External_RegInfo *) (option + 1);
16349                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
16350                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16351                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16352                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16353                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16354                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
16355
16356                       printf ("GPR %08lx  GP 0x",
16357                               reginfo.ri_gprmask);
16358                       printf_vma (reginfo.ri_gp_value);
16359                       printf ("\n");
16360
16361                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
16362                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16363                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16364                     }
16365                   ++option;
16366                   continue;
16367                 case ODK_EXCEPTIONS:
16368                   fputs (" EXCEPTIONS fpe_min(", stdout);
16369                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
16370                   fputs (") fpe_max(", stdout);
16371                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
16372                   fputs (")", stdout);
16373
16374                   if (option->info & OEX_PAGE0)
16375                     fputs (" PAGE0", stdout);
16376                   if (option->info & OEX_SMM)
16377                     fputs (" SMM", stdout);
16378                   if (option->info & OEX_FPDBUG)
16379                     fputs (" FPDBUG", stdout);
16380                   if (option->info & OEX_DISMISS)
16381                     fputs (" DISMISS", stdout);
16382                   break;
16383                 case ODK_PAD:
16384                   fputs (" PAD       ", stdout);
16385                   if (option->info & OPAD_PREFIX)
16386                     fputs (" PREFIX", stdout);
16387                   if (option->info & OPAD_POSTFIX)
16388                     fputs (" POSTFIX", stdout);
16389                   if (option->info & OPAD_SYMBOL)
16390                     fputs (" SYMBOL", stdout);
16391                   break;
16392                 case ODK_HWPATCH:
16393                   fputs (" HWPATCH   ", stdout);
16394                   if (option->info & OHW_R4KEOP)
16395                     fputs (" R4KEOP", stdout);
16396                   if (option->info & OHW_R8KPFETCH)
16397                     fputs (" R8KPFETCH", stdout);
16398                   if (option->info & OHW_R5KEOP)
16399                     fputs (" R5KEOP", stdout);
16400                   if (option->info & OHW_R5KCVTL)
16401                     fputs (" R5KCVTL", stdout);
16402                   break;
16403                 case ODK_FILL:
16404                   fputs (" FILL       ", stdout);
16405                   /* XXX Print content of info word?  */
16406                   break;
16407                 case ODK_TAGS:
16408                   fputs (" TAGS       ", stdout);
16409                   /* XXX Print content of info word?  */
16410                   break;
16411                 case ODK_HWAND:
16412                   fputs (" HWAND     ", stdout);
16413                   if (option->info & OHWA0_R4KEOP_CHECKED)
16414                     fputs (" R4KEOP_CHECKED", stdout);
16415                   if (option->info & OHWA0_R4KEOP_CLEAN)
16416                     fputs (" R4KEOP_CLEAN", stdout);
16417                   break;
16418                 case ODK_HWOR:
16419                   fputs (" HWOR      ", stdout);
16420                   if (option->info & OHWA0_R4KEOP_CHECKED)
16421                     fputs (" R4KEOP_CHECKED", stdout);
16422                   if (option->info & OHWA0_R4KEOP_CLEAN)
16423                     fputs (" R4KEOP_CLEAN", stdout);
16424                   break;
16425                 case ODK_GP_GROUP:
16426                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
16427                           option->info & OGP_GROUP,
16428                           (option->info & OGP_SELF) >> 16);
16429                   break;
16430                 case ODK_IDENT:
16431                   printf (" IDENT     %#06lx  self-contained %#06lx",
16432                           option->info & OGP_GROUP,
16433                           (option->info & OGP_SELF) >> 16);
16434                   break;
16435                 default:
16436                   /* This shouldn't happen.  */
16437                   printf (" %3d ???     %d %lx",
16438                           option->kind, option->section, option->info);
16439                   break;
16440                 }
16441
16442               len = sizeof (* eopt);
16443               while (len < option->size)
16444                 {
16445                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
16446
16447                   if (ISPRINT (datum))
16448                     printf ("%c", datum);
16449                   else
16450                     printf ("\\%03o", datum);
16451                   len ++;
16452                 }
16453               fputs ("\n", stdout);
16454
16455               offset += option->size;
16456               ++option;
16457             }
16458
16459           free (eopt);
16460         }
16461       else
16462         res = FALSE;
16463     }
16464
16465   if (conflicts_offset != 0 && conflictsno != 0)
16466     {
16467       Elf32_Conflict * iconf;
16468       size_t cnt;
16469
16470       if (dynamic_symbols == NULL)
16471         {
16472           error (_("conflict list found without a dynamic symbol table\n"));
16473           return FALSE;
16474         }
16475
16476       /* PR 21345 - print a slightly more helpful error message
16477          if we are sure that the cmalloc will fail.  */
16478       if (conflictsno * sizeof (* iconf) > filedata->file_size)
16479         {
16480           error (_("Overlarge number of conflicts detected: %lx\n"),
16481                  (long) conflictsno);
16482           return FALSE;
16483         }
16484
16485       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16486       if (iconf == NULL)
16487         {
16488           error (_("Out of memory allocating space for dynamic conflicts\n"));
16489           return FALSE;
16490         }
16491
16492       if (is_32bit_elf)
16493         {
16494           Elf32_External_Conflict * econf32;
16495
16496           econf32 = (Elf32_External_Conflict *)
16497               get_data (NULL, filedata, conflicts_offset, conflictsno,
16498                         sizeof (* econf32), _("conflict"));
16499           if (!econf32)
16500             return FALSE;
16501
16502           for (cnt = 0; cnt < conflictsno; ++cnt)
16503             iconf[cnt] = BYTE_GET (econf32[cnt]);
16504
16505           free (econf32);
16506         }
16507       else
16508         {
16509           Elf64_External_Conflict * econf64;
16510
16511           econf64 = (Elf64_External_Conflict *)
16512               get_data (NULL, filedata, conflicts_offset, conflictsno,
16513                         sizeof (* econf64), _("conflict"));
16514           if (!econf64)
16515             return FALSE;
16516
16517           for (cnt = 0; cnt < conflictsno; ++cnt)
16518             iconf[cnt] = BYTE_GET (econf64[cnt]);
16519
16520           free (econf64);
16521         }
16522
16523       printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16524                         "\nSection '.conflict' contains %lu entries:\n",
16525                         (unsigned long) conflictsno),
16526               (unsigned long) conflictsno);
16527       puts (_("  Num:    Index       Value  Name"));
16528
16529       for (cnt = 0; cnt < conflictsno; ++cnt)
16530         {
16531           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
16532
16533           if (iconf[cnt] >= num_dynamic_syms)
16534             printf (_("<corrupt symbol index>"));
16535           else
16536             {
16537               Elf_Internal_Sym * psym;
16538
16539               psym = & dynamic_symbols[iconf[cnt]];
16540               print_vma (psym->st_value, FULL_HEX);
16541               putchar (' ');
16542               if (VALID_DYNAMIC_NAME (psym->st_name))
16543                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16544               else
16545                 printf (_("<corrupt: %14ld>"), psym->st_name);
16546             }
16547           putchar ('\n');
16548         }
16549
16550       free (iconf);
16551     }
16552
16553   if (pltgot != 0 && local_gotno != 0)
16554     {
16555       bfd_vma ent, local_end, global_end;
16556       size_t i, offset;
16557       unsigned char * data;
16558       unsigned char * data_end;
16559       int addr_size;
16560
16561       ent = pltgot;
16562       addr_size = (is_32bit_elf ? 4 : 8);
16563       local_end = pltgot + local_gotno * addr_size;
16564
16565       /* PR binutils/17533 file: 012-111227-0.004  */
16566       if (symtabno < gotsym)
16567         {
16568           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16569                  (unsigned long) gotsym, (unsigned long) symtabno);
16570           return FALSE;
16571         }
16572
16573       global_end = local_end + (symtabno - gotsym) * addr_size;
16574       /* PR 17531: file: 54c91a34.  */
16575       if (global_end < local_end)
16576         {
16577           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
16578           return FALSE;
16579         }
16580
16581       offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
16582       data = (unsigned char *) get_data (NULL, filedata, offset,
16583                                          global_end - pltgot, 1,
16584                                          _("Global Offset Table data"));
16585       /* PR 12855: Null data is handled gracefully throughout.  */
16586       data_end = data + (global_end - pltgot);
16587
16588       printf (_("\nPrimary GOT:\n"));
16589       printf (_(" Canonical gp value: "));
16590       print_vma (pltgot + 0x7ff0, LONG_HEX);
16591       printf ("\n\n");
16592
16593       printf (_(" Reserved entries:\n"));
16594       printf (_("  %*s %10s %*s Purpose\n"),
16595               addr_size * 2, _("Address"), _("Access"),
16596               addr_size * 2, _("Initial"));
16597       ent = print_mips_got_entry (data, pltgot, ent, data_end);
16598       printf (_(" Lazy resolver\n"));
16599       if (ent == (bfd_vma) -1)
16600         goto got_print_fail;
16601
16602       /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16603          This entry will be used by some runtime loaders, to store the
16604          module pointer.  Otherwise this is an ordinary local entry.
16605          PR 21344: Check for the entry being fully available before
16606          fetching it.  */
16607       if (data
16608           && data + ent - pltgot + addr_size <= data_end
16609           && (byte_get (data + ent - pltgot, addr_size)
16610               >> (addr_size * 8 - 1)) != 0)
16611         {
16612           ent = print_mips_got_entry (data, pltgot, ent, data_end);
16613           printf (_(" Module pointer (GNU extension)\n"));
16614           if (ent == (bfd_vma) -1)
16615             goto got_print_fail;
16616         }
16617       printf ("\n");
16618
16619       if (data != NULL && ent < local_end)
16620         {
16621           printf (_(" Local entries:\n"));
16622           printf ("  %*s %10s %*s\n",
16623                   addr_size * 2, _("Address"), _("Access"),
16624                   addr_size * 2, _("Initial"));
16625           while (ent < local_end)
16626             {
16627               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16628               printf ("\n");
16629               if (ent == (bfd_vma) -1)
16630                 goto got_print_fail;
16631             }
16632           printf ("\n");
16633         }
16634
16635       if (data != NULL && gotsym < symtabno)
16636         {
16637           int sym_width;
16638
16639           printf (_(" Global entries:\n"));
16640           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
16641                   addr_size * 2, _("Address"),
16642                   _("Access"),
16643                   addr_size * 2, _("Initial"),
16644                   addr_size * 2, _("Sym.Val."),
16645                   _("Type"),
16646                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
16647                   _("Ndx"), _("Name"));
16648
16649           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
16650
16651           for (i = gotsym; i < symtabno; i++)
16652             {
16653               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16654               printf (" ");
16655
16656               if (dynamic_symbols == NULL)
16657                 printf (_("<no dynamic symbols>"));
16658               else if (i < num_dynamic_syms)
16659                 {
16660                   Elf_Internal_Sym * psym = dynamic_symbols + i;
16661
16662                   print_vma (psym->st_value, LONG_HEX);
16663                   printf (" %-7s %3s ",
16664                           get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16665                           get_symbol_index_type (filedata, psym->st_shndx));
16666
16667                   if (VALID_DYNAMIC_NAME (psym->st_name))
16668                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16669                   else
16670                     printf (_("<corrupt: %14ld>"), psym->st_name);
16671                 }
16672               else
16673                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16674                         (unsigned long) i);
16675
16676               printf ("\n");
16677               if (ent == (bfd_vma) -1)
16678                 break;
16679             }
16680           printf ("\n");
16681         }
16682
16683     got_print_fail:
16684       if (data)
16685         free (data);
16686     }
16687
16688   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
16689     {
16690       bfd_vma ent, end;
16691       size_t offset, rel_offset;
16692       unsigned long count, i;
16693       unsigned char * data;
16694       int addr_size, sym_width;
16695       Elf_Internal_Rela * rels;
16696
16697       rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
16698       if (pltrel == DT_RELA)
16699         {
16700           if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16701             return FALSE;
16702         }
16703       else
16704         {
16705           if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16706             return FALSE;
16707         }
16708
16709       ent = mips_pltgot;
16710       addr_size = (is_32bit_elf ? 4 : 8);
16711       end = mips_pltgot + (2 + count) * addr_size;
16712
16713       offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
16714       data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
16715                                          1, _("Procedure Linkage Table data"));
16716       if (data == NULL)
16717         return FALSE;
16718
16719       printf ("\nPLT GOT:\n\n");
16720       printf (_(" Reserved entries:\n"));
16721       printf (_("  %*s %*s Purpose\n"),
16722               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
16723       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16724       printf (_(" PLT lazy resolver\n"));
16725       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16726       printf (_(" Module pointer\n"));
16727       printf ("\n");
16728
16729       printf (_(" Entries:\n"));
16730       printf ("  %*s %*s %*s %-7s %3s %s\n",
16731               addr_size * 2, _("Address"),
16732               addr_size * 2, _("Initial"),
16733               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16734       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
16735       for (i = 0; i < count; i++)
16736         {
16737           unsigned long idx = get_reloc_symindex (rels[i].r_info);
16738
16739           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16740           printf (" ");
16741
16742           if (idx >= num_dynamic_syms)
16743             printf (_("<corrupt symbol index: %lu>"), idx);
16744           else
16745             {
16746               Elf_Internal_Sym * psym = dynamic_symbols + idx;
16747
16748               print_vma (psym->st_value, LONG_HEX);
16749               printf (" %-7s %3s ",
16750                       get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16751                       get_symbol_index_type (filedata, psym->st_shndx));
16752               if (VALID_DYNAMIC_NAME (psym->st_name))
16753                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16754               else
16755                 printf (_("<corrupt: %14ld>"), psym->st_name);
16756             }
16757           printf ("\n");
16758         }
16759       printf ("\n");
16760
16761       if (data)
16762         free (data);
16763       free (rels);
16764     }
16765
16766   return res;
16767 }
16768
16769 static bfd_boolean
16770 process_nds32_specific (Filedata * filedata)
16771 {
16772   Elf_Internal_Shdr *sect = NULL;
16773
16774   sect = find_section (filedata, ".nds32_e_flags");
16775   if (sect != NULL)
16776     {
16777       unsigned int *flag;
16778
16779       printf ("\nNDS32 elf flags section:\n");
16780       flag = get_data (NULL, filedata, sect->sh_offset, 1,
16781                        sect->sh_size, _("NDS32 elf flags section"));
16782
16783       if (! flag)
16784         return FALSE;
16785
16786       switch ((*flag) & 0x3)
16787         {
16788         case 0:
16789           printf ("(VEC_SIZE):\tNo entry.\n");
16790           break;
16791         case 1:
16792           printf ("(VEC_SIZE):\t4 bytes\n");
16793           break;
16794         case 2:
16795           printf ("(VEC_SIZE):\t16 bytes\n");
16796           break;
16797         case 3:
16798           printf ("(VEC_SIZE):\treserved\n");
16799           break;
16800         }
16801     }
16802
16803   return TRUE;
16804 }
16805
16806 static bfd_boolean
16807 process_gnu_liblist (Filedata * filedata)
16808 {
16809   Elf_Internal_Shdr * section;
16810   Elf_Internal_Shdr * string_sec;
16811   Elf32_External_Lib * elib;
16812   char * strtab;
16813   size_t strtab_size;
16814   size_t cnt;
16815   unsigned long num_liblist;
16816   unsigned i;
16817   bfd_boolean res = TRUE;
16818
16819   if (! do_arch)
16820     return TRUE;
16821
16822   for (i = 0, section = filedata->section_headers;
16823        i < filedata->file_header.e_shnum;
16824        i++, section++)
16825     {
16826       switch (section->sh_type)
16827         {
16828         case SHT_GNU_LIBLIST:
16829           if (section->sh_link >= filedata->file_header.e_shnum)
16830             break;
16831
16832           elib = (Elf32_External_Lib *)
16833               get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
16834                         _("liblist section data"));
16835
16836           if (elib == NULL)
16837             {
16838               res = FALSE;
16839               break;
16840             }
16841
16842           string_sec = filedata->section_headers + section->sh_link;
16843           strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
16844                                       string_sec->sh_size,
16845                                       _("liblist string table"));
16846           if (strtab == NULL
16847               || section->sh_entsize != sizeof (Elf32_External_Lib))
16848             {
16849               free (elib);
16850               free (strtab);
16851               res = FALSE;
16852               break;
16853             }
16854           strtab_size = string_sec->sh_size;
16855
16856           num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
16857           printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16858                             "\nLibrary list section '%s' contains %lu entries:\n",
16859                             num_liblist),
16860                   printable_section_name (filedata, section),
16861                   num_liblist);
16862
16863           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
16864
16865           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16866                ++cnt)
16867             {
16868               Elf32_Lib liblist;
16869               time_t atime;
16870               char timebuf[128];
16871               struct tm * tmp;
16872
16873               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16874               atime = BYTE_GET (elib[cnt].l_time_stamp);
16875               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16876               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16877               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16878
16879               tmp = gmtime (&atime);
16880               snprintf (timebuf, sizeof (timebuf),
16881                         "%04u-%02u-%02uT%02u:%02u:%02u",
16882                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16883                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16884
16885               printf ("%3lu: ", (unsigned long) cnt);
16886               if (do_wide)
16887                 printf ("%-20s", liblist.l_name < strtab_size
16888                         ? strtab + liblist.l_name : _("<corrupt>"));
16889               else
16890                 printf ("%-20.20s", liblist.l_name < strtab_size
16891                         ? strtab + liblist.l_name : _("<corrupt>"));
16892               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16893                       liblist.l_version, liblist.l_flags);
16894             }
16895
16896           free (elib);
16897           free (strtab);
16898         }
16899     }
16900
16901   return res;
16902 }
16903
16904 static const char *
16905 get_note_type (Filedata * filedata, unsigned e_type)
16906 {
16907   static char buff[64];
16908
16909   if (filedata->file_header.e_type == ET_CORE)
16910     switch (e_type)
16911       {
16912       case NT_AUXV:
16913         return _("NT_AUXV (auxiliary vector)");
16914       case NT_PRSTATUS:
16915         return _("NT_PRSTATUS (prstatus structure)");
16916       case NT_FPREGSET:
16917         return _("NT_FPREGSET (floating point registers)");
16918       case NT_PRPSINFO:
16919         return _("NT_PRPSINFO (prpsinfo structure)");
16920       case NT_TASKSTRUCT:
16921         return _("NT_TASKSTRUCT (task structure)");
16922       case NT_PRXFPREG:
16923         return _("NT_PRXFPREG (user_xfpregs structure)");
16924       case NT_PPC_VMX:
16925         return _("NT_PPC_VMX (ppc Altivec registers)");
16926       case NT_PPC_VSX:
16927         return _("NT_PPC_VSX (ppc VSX registers)");
16928       case NT_PPC_TAR:
16929         return _("NT_PPC_TAR (ppc TAR register)");
16930       case NT_PPC_PPR:
16931         return _("NT_PPC_PPR (ppc PPR register)");
16932       case NT_PPC_DSCR:
16933         return _("NT_PPC_DSCR (ppc DSCR register)");
16934       case NT_PPC_EBB:
16935         return _("NT_PPC_EBB (ppc EBB registers)");
16936       case NT_PPC_PMU:
16937         return _("NT_PPC_PMU (ppc PMU registers)");
16938       case NT_PPC_TM_CGPR:
16939         return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16940       case NT_PPC_TM_CFPR:
16941         return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16942       case NT_PPC_TM_CVMX:
16943         return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16944       case NT_PPC_TM_CVSX:
16945         return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
16946       case NT_PPC_TM_SPR:
16947         return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16948       case NT_PPC_TM_CTAR:
16949         return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16950       case NT_PPC_TM_CPPR:
16951         return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16952       case NT_PPC_TM_CDSCR:
16953         return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16954       case NT_386_TLS:
16955         return _("NT_386_TLS (x86 TLS information)");
16956       case NT_386_IOPERM:
16957         return _("NT_386_IOPERM (x86 I/O permissions)");
16958       case NT_X86_XSTATE:
16959         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16960       case NT_S390_HIGH_GPRS:
16961         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16962       case NT_S390_TIMER:
16963         return _("NT_S390_TIMER (s390 timer register)");
16964       case NT_S390_TODCMP:
16965         return _("NT_S390_TODCMP (s390 TOD comparator register)");
16966       case NT_S390_TODPREG:
16967         return _("NT_S390_TODPREG (s390 TOD programmable register)");
16968       case NT_S390_CTRS:
16969         return _("NT_S390_CTRS (s390 control registers)");
16970       case NT_S390_PREFIX:
16971         return _("NT_S390_PREFIX (s390 prefix register)");
16972       case NT_S390_LAST_BREAK:
16973         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16974       case NT_S390_SYSTEM_CALL:
16975         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16976       case NT_S390_TDB:
16977         return _("NT_S390_TDB (s390 transaction diagnostic block)");
16978       case NT_S390_VXRS_LOW:
16979         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16980       case NT_S390_VXRS_HIGH:
16981         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16982       case NT_S390_GS_CB:
16983         return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16984       case NT_S390_GS_BC:
16985         return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16986       case NT_ARM_VFP:
16987         return _("NT_ARM_VFP (arm VFP registers)");
16988       case NT_ARM_TLS:
16989         return _("NT_ARM_TLS (AArch TLS registers)");
16990       case NT_ARM_HW_BREAK:
16991         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16992       case NT_ARM_HW_WATCH:
16993         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16994       case NT_PSTATUS:
16995         return _("NT_PSTATUS (pstatus structure)");
16996       case NT_FPREGS:
16997         return _("NT_FPREGS (floating point registers)");
16998       case NT_PSINFO:
16999         return _("NT_PSINFO (psinfo structure)");
17000       case NT_LWPSTATUS:
17001         return _("NT_LWPSTATUS (lwpstatus_t structure)");
17002       case NT_LWPSINFO:
17003         return _("NT_LWPSINFO (lwpsinfo_t structure)");
17004       case NT_WIN32PSTATUS:
17005         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17006       case NT_SIGINFO:
17007         return _("NT_SIGINFO (siginfo_t data)");
17008       case NT_FILE:
17009         return _("NT_FILE (mapped files)");
17010       default:
17011         break;
17012       }
17013   else
17014     switch (e_type)
17015       {
17016       case NT_VERSION:
17017         return _("NT_VERSION (version)");
17018       case NT_ARCH:
17019         return _("NT_ARCH (architecture)");
17020       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
17021         return _("OPEN");
17022       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
17023         return _("func");
17024       default:
17025         break;
17026       }
17027
17028   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17029   return buff;
17030 }
17031
17032 static bfd_boolean
17033 print_core_note (Elf_Internal_Note *pnote)
17034 {
17035   unsigned int addr_size = is_32bit_elf ? 4 : 8;
17036   bfd_vma count, page_size;
17037   unsigned char *descdata, *filenames, *descend;
17038
17039   if (pnote->type != NT_FILE)
17040     {
17041       if (do_wide)
17042         printf ("\n");
17043       return TRUE;
17044     }
17045
17046 #ifndef BFD64
17047   if (!is_32bit_elf)
17048     {
17049       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
17050       /* Still "successful".  */
17051       return TRUE;
17052     }
17053 #endif
17054
17055   if (pnote->descsz < 2 * addr_size)
17056     {
17057       error (_("    Malformed note - too short for header\n"));
17058       return FALSE;
17059     }
17060
17061   descdata = (unsigned char *) pnote->descdata;
17062   descend = descdata + pnote->descsz;
17063
17064   if (descdata[pnote->descsz - 1] != '\0')
17065     {
17066       error (_("    Malformed note - does not end with \\0\n"));
17067       return FALSE;
17068     }
17069
17070   count = byte_get (descdata, addr_size);
17071   descdata += addr_size;
17072
17073   page_size = byte_get (descdata, addr_size);
17074   descdata += addr_size;
17075
17076   if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
17077       || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
17078     {
17079       error (_("    Malformed note - too short for supplied file count\n"));
17080       return FALSE;
17081     }
17082
17083   printf (_("    Page size: "));
17084   print_vma (page_size, DEC);
17085   printf ("\n");
17086
17087   printf (_("    %*s%*s%*s\n"),
17088           (int) (2 + 2 * addr_size), _("Start"),
17089           (int) (4 + 2 * addr_size), _("End"),
17090           (int) (4 + 2 * addr_size), _("Page Offset"));
17091   filenames = descdata + count * 3 * addr_size;
17092   while (count-- > 0)
17093     {
17094       bfd_vma start, end, file_ofs;
17095
17096       if (filenames == descend)
17097         {
17098           error (_("    Malformed note - filenames end too early\n"));
17099           return FALSE;
17100         }
17101
17102       start = byte_get (descdata, addr_size);
17103       descdata += addr_size;
17104       end = byte_get (descdata, addr_size);
17105       descdata += addr_size;
17106       file_ofs = byte_get (descdata, addr_size);
17107       descdata += addr_size;
17108
17109       printf ("    ");
17110       print_vma (start, FULL_HEX);
17111       printf ("  ");
17112       print_vma (end, FULL_HEX);
17113       printf ("  ");
17114       print_vma (file_ofs, FULL_HEX);
17115       printf ("\n        %s\n", filenames);
17116
17117       filenames += 1 + strlen ((char *) filenames);
17118     }
17119
17120   return TRUE;
17121 }
17122
17123 static const char *
17124 get_gnu_elf_note_type (unsigned e_type)
17125 {
17126   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
17127   switch (e_type)
17128     {
17129     case NT_GNU_ABI_TAG:
17130       return _("NT_GNU_ABI_TAG (ABI version tag)");
17131     case NT_GNU_HWCAP:
17132       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17133     case NT_GNU_BUILD_ID:
17134       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17135     case NT_GNU_GOLD_VERSION:
17136       return _("NT_GNU_GOLD_VERSION (gold version)");
17137     case NT_GNU_PROPERTY_TYPE_0:
17138       return _("NT_GNU_PROPERTY_TYPE_0");
17139     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
17140       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17141     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
17142       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17143     default:
17144       {
17145         static char buff[64];
17146
17147         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17148         return buff;
17149       }
17150     }
17151 }
17152
17153 static void
17154 decode_x86_compat_isa (unsigned int bitmask)
17155 {
17156   while (bitmask)
17157     {
17158       unsigned int bit = bitmask & (- bitmask);
17159
17160       bitmask &= ~ bit;
17161       switch (bit)
17162         {
17163         case GNU_PROPERTY_X86_COMPAT_ISA_1_486:
17164           printf ("i486");
17165           break;
17166         case GNU_PROPERTY_X86_COMPAT_ISA_1_586:
17167           printf ("586");
17168           break;
17169         case GNU_PROPERTY_X86_COMPAT_ISA_1_686:
17170           printf ("686");
17171           break;
17172         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE:
17173           printf ("SSE");
17174           break;
17175         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2:
17176           printf ("SSE2");
17177           break;
17178         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3:
17179           printf ("SSE3");
17180           break;
17181         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3:
17182           printf ("SSSE3");
17183           break;
17184         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1:
17185           printf ("SSE4_1");
17186           break;
17187         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2:
17188           printf ("SSE4_2");
17189           break;
17190         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX:
17191           printf ("AVX");
17192           break;
17193         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2:
17194           printf ("AVX2");
17195           break;
17196         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F:
17197           printf ("AVX512F");
17198           break;
17199         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD:
17200           printf ("AVX512CD");
17201           break;
17202         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER:
17203           printf ("AVX512ER");
17204           break;
17205         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF:
17206           printf ("AVX512PF");
17207           break;
17208         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL:
17209           printf ("AVX512VL");
17210           break;
17211         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ:
17212           printf ("AVX512DQ");
17213           break;
17214         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW:
17215           printf ("AVX512BW");
17216           break;
17217         default:
17218           printf (_("<unknown: %x>"), bit);
17219           break;
17220         }
17221       if (bitmask)
17222         printf (", ");
17223     }
17224 }
17225
17226 static void
17227 decode_x86_isa (unsigned int bitmask)
17228 {
17229   if (!bitmask)
17230     {
17231       printf (_("<None>"));
17232       return;
17233     }
17234
17235   while (bitmask)
17236     {
17237       unsigned int bit = bitmask & (- bitmask);
17238
17239       bitmask &= ~ bit;
17240       switch (bit)
17241         {
17242         case GNU_PROPERTY_X86_ISA_1_CMOV:
17243           printf ("CMOV");
17244           break;
17245         case GNU_PROPERTY_X86_ISA_1_SSE:
17246           printf ("SSE");
17247           break;
17248         case GNU_PROPERTY_X86_ISA_1_SSE2:
17249           printf ("SSE2");
17250           break;
17251         case GNU_PROPERTY_X86_ISA_1_SSE3:
17252           printf ("SSE3");
17253           break;
17254         case GNU_PROPERTY_X86_ISA_1_SSSE3:
17255           printf ("SSSE3");
17256           break;
17257         case GNU_PROPERTY_X86_ISA_1_SSE4_1:
17258           printf ("SSE4_1");
17259           break;
17260         case GNU_PROPERTY_X86_ISA_1_SSE4_2:
17261           printf ("SSE4_2");
17262           break;
17263         case GNU_PROPERTY_X86_ISA_1_AVX:
17264           printf ("AVX");
17265           break;
17266         case GNU_PROPERTY_X86_ISA_1_AVX2:
17267           printf ("AVX2");
17268           break;
17269         case GNU_PROPERTY_X86_ISA_1_FMA:
17270           printf ("FMA");
17271           break;
17272         case GNU_PROPERTY_X86_ISA_1_AVX512F:
17273           printf ("AVX512F");
17274           break;
17275         case GNU_PROPERTY_X86_ISA_1_AVX512CD:
17276           printf ("AVX512CD");
17277           break;
17278         case GNU_PROPERTY_X86_ISA_1_AVX512ER:
17279           printf ("AVX512ER");
17280           break;
17281         case GNU_PROPERTY_X86_ISA_1_AVX512PF:
17282           printf ("AVX512PF");
17283           break;
17284         case GNU_PROPERTY_X86_ISA_1_AVX512VL:
17285           printf ("AVX512VL");
17286           break;
17287         case GNU_PROPERTY_X86_ISA_1_AVX512DQ:
17288           printf ("AVX512DQ");
17289           break;
17290         case GNU_PROPERTY_X86_ISA_1_AVX512BW:
17291           printf ("AVX512BW");
17292           break;
17293         case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS:
17294           printf ("AVX512_4FMAPS");
17295           break;
17296         case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW:
17297           printf ("AVX512_4VNNIW");
17298           break;
17299         case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG:
17300           printf ("AVX512_BITALG");
17301           break;
17302         case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA:
17303           printf ("AVX512_IFMA");
17304           break;
17305         case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI:
17306           printf ("AVX512_VBMI");
17307           break;
17308         case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2:
17309           printf ("AVX512_VBMI2");
17310           break;
17311         case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI:
17312           printf ("AVX512_VNNI");
17313           break;
17314         case GNU_PROPERTY_X86_ISA_1_AVX512_BF16:
17315           printf ("AVX512_BF16");
17316           break;
17317         default:
17318           printf (_("<unknown: %x>"), bit);
17319           break;
17320         }
17321       if (bitmask)
17322         printf (", ");
17323     }
17324 }
17325
17326 static void
17327 decode_x86_feature_1 (unsigned int bitmask)
17328 {
17329   if (!bitmask)
17330     {
17331       printf (_("<None>"));
17332       return;
17333     }
17334
17335   while (bitmask)
17336     {
17337       unsigned int bit = bitmask & (- bitmask);
17338
17339       bitmask &= ~ bit;
17340       switch (bit)
17341         {
17342         case GNU_PROPERTY_X86_FEATURE_1_IBT:
17343           printf ("IBT");
17344           break;
17345         case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
17346           printf ("SHSTK");
17347           break;
17348         default:
17349           printf (_("<unknown: %x>"), bit);
17350           break;
17351         }
17352       if (bitmask)
17353         printf (", ");
17354     }
17355 }
17356
17357 static void
17358 decode_x86_feature_2 (unsigned int bitmask)
17359 {
17360   if (!bitmask)
17361     {
17362       printf (_("<None>"));
17363       return;
17364     }
17365
17366   while (bitmask)
17367     {
17368       unsigned int bit = bitmask & (- bitmask);
17369
17370       bitmask &= ~ bit;
17371       switch (bit)
17372         {
17373         case GNU_PROPERTY_X86_FEATURE_2_X86:
17374           printf ("x86");
17375           break;
17376         case GNU_PROPERTY_X86_FEATURE_2_X87:
17377           printf ("x87");
17378           break;
17379         case GNU_PROPERTY_X86_FEATURE_2_MMX:
17380           printf ("MMX");
17381           break;
17382         case GNU_PROPERTY_X86_FEATURE_2_XMM:
17383           printf ("XMM");
17384           break;
17385         case GNU_PROPERTY_X86_FEATURE_2_YMM:
17386           printf ("YMM");
17387           break;
17388         case GNU_PROPERTY_X86_FEATURE_2_ZMM:
17389           printf ("ZMM");
17390           break;
17391         case GNU_PROPERTY_X86_FEATURE_2_FXSR:
17392           printf ("FXSR");
17393           break;
17394         case GNU_PROPERTY_X86_FEATURE_2_XSAVE:
17395           printf ("XSAVE");
17396           break;
17397         case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT:
17398           printf ("XSAVEOPT");
17399           break;
17400         case GNU_PROPERTY_X86_FEATURE_2_XSAVEC:
17401           printf ("XSAVEC");
17402           break;
17403         default:
17404           printf (_("<unknown: %x>"), bit);
17405           break;
17406         }
17407       if (bitmask)
17408         printf (", ");
17409     }
17410 }
17411
17412 static void
17413 decode_aarch64_feature_1_and (unsigned int bitmask)
17414 {
17415   while (bitmask)
17416     {
17417       unsigned int bit = bitmask & (- bitmask);
17418
17419       bitmask &= ~ bit;
17420       switch (bit)
17421         {
17422         case GNU_PROPERTY_AARCH64_FEATURE_1_BTI:
17423           printf ("BTI");
17424           break;
17425
17426         case GNU_PROPERTY_AARCH64_FEATURE_1_PAC:
17427           printf ("PAC");
17428           break;
17429
17430         default:
17431           printf (_("<unknown: %x>"), bit);
17432           break;
17433         }
17434       if (bitmask)
17435         printf (", ");
17436     }
17437 }
17438
17439 static void
17440 print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
17441 {
17442   unsigned char * ptr = (unsigned char *) pnote->descdata;
17443   unsigned char * ptr_end = ptr + pnote->descsz;
17444   unsigned int    size = is_32bit_elf ? 4 : 8;
17445
17446   printf (_("      Properties: "));
17447
17448   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
17449     {
17450       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
17451       return;
17452     }
17453
17454   while (ptr < ptr_end)
17455     {
17456       unsigned int j;
17457       unsigned int type;
17458       unsigned int datasz;
17459
17460       if ((size_t) (ptr_end - ptr) < 8)
17461         {
17462           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
17463           break;
17464         }
17465
17466       type = byte_get (ptr, 4);
17467       datasz = byte_get (ptr + 4, 4);
17468
17469       ptr += 8;
17470
17471       if (datasz > (size_t) (ptr_end - ptr))
17472         {
17473           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17474                   type, datasz);
17475           break;
17476         }
17477
17478       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
17479         {
17480           if (filedata->file_header.e_machine == EM_X86_64
17481               || filedata->file_header.e_machine == EM_IAMCU
17482               || filedata->file_header.e_machine == EM_386)
17483             {
17484               unsigned int bitmask;
17485
17486               if (datasz == 4)
17487                 bitmask = byte_get (ptr, 4);
17488               else
17489                 bitmask = 0;
17490
17491               switch (type)
17492                 {
17493                 case GNU_PROPERTY_X86_ISA_1_USED:
17494                   if (datasz != 4)
17495                     printf (_("x86 ISA used: <corrupt length: %#x> "),
17496                             datasz);
17497                   else
17498                     {
17499                       printf ("x86 ISA used: ");
17500                       decode_x86_isa (bitmask);
17501                     }
17502                   goto next;
17503
17504                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
17505                   if (datasz != 4)
17506                     printf (_("x86 ISA needed: <corrupt length: %#x> "),
17507                             datasz);
17508                   else
17509                     {
17510                       printf ("x86 ISA needed: ");
17511                       decode_x86_isa (bitmask);
17512                     }
17513                   goto next;
17514
17515                 case GNU_PROPERTY_X86_FEATURE_1_AND:
17516                   if (datasz != 4)
17517                     printf (_("x86 feature: <corrupt length: %#x> "),
17518                             datasz);
17519                   else
17520                     {
17521                       printf ("x86 feature: ");
17522                       decode_x86_feature_1 (bitmask);
17523                     }
17524                   goto next;
17525
17526                 case GNU_PROPERTY_X86_FEATURE_2_USED:
17527                   if (datasz != 4)
17528                     printf (_("x86 feature used: <corrupt length: %#x> "),
17529                             datasz);
17530                   else
17531                     {
17532                       printf ("x86 feature used: ");
17533                       decode_x86_feature_2 (bitmask);
17534                     }
17535                   goto next;
17536
17537                 case GNU_PROPERTY_X86_FEATURE_2_NEEDED:
17538                   if (datasz != 4)
17539                     printf (_("x86 feature needed: <corrupt length: %#x> "), datasz);
17540                   else
17541                     {
17542                       printf ("x86 feature needed: ");
17543                       decode_x86_feature_2 (bitmask);
17544                     }
17545                   goto next;
17546
17547                 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED:
17548                   if (datasz != 4)
17549                     printf (_("x86 ISA used: <corrupt length: %#x> "),
17550                             datasz);
17551                   else
17552                     {
17553                       printf ("x86 ISA used: ");
17554                       decode_x86_compat_isa (bitmask);
17555                     }
17556                   goto next;
17557
17558                 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED:
17559                   if (datasz != 4)
17560                     printf (_("x86 ISA needed: <corrupt length: %#x> "),
17561                             datasz);
17562                   else
17563                     {
17564                       printf ("x86 ISA needed: ");
17565                       decode_x86_compat_isa (bitmask);
17566                     }
17567                   goto next;
17568
17569                 default:
17570                   break;
17571                 }
17572             }
17573           else if (filedata->file_header.e_machine == EM_AARCH64)
17574             {
17575               if (type == GNU_PROPERTY_AARCH64_FEATURE_1_AND)
17576                 {
17577                   printf ("AArch64 feature: ");
17578                   if (datasz != 4)
17579                     printf (_("<corrupt length: %#x> "), datasz);
17580                   else
17581                     decode_aarch64_feature_1_and (byte_get (ptr, 4));
17582                   goto next;
17583                 }
17584             }
17585         }
17586       else
17587         {
17588           switch (type)
17589             {
17590             case GNU_PROPERTY_STACK_SIZE:
17591               printf (_("stack size: "));
17592               if (datasz != size)
17593                 printf (_("<corrupt length: %#x> "), datasz);
17594               else
17595                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
17596               goto next;
17597
17598             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
17599               printf ("no copy on protected ");
17600               if (datasz)
17601                 printf (_("<corrupt length: %#x> "), datasz);
17602               goto next;
17603
17604             default:
17605               break;
17606             }
17607         }
17608
17609       if (type < GNU_PROPERTY_LOPROC)
17610         printf (_("<unknown type %#x data: "), type);
17611       else if (type < GNU_PROPERTY_LOUSER)
17612         printf (_("<procesor-specific type %#x data: "), type);
17613       else
17614         printf (_("<application-specific type %#x data: "), type);
17615       for (j = 0; j < datasz; ++j)
17616         printf ("%02x ", ptr[j] & 0xff);
17617       printf (">");
17618
17619 next:
17620       ptr += ((datasz + (size - 1)) & ~ (size - 1));
17621       if (ptr == ptr_end)
17622         break;
17623
17624       if (do_wide)
17625         printf (", ");
17626       else
17627         printf ("\n\t");
17628     }
17629
17630   printf ("\n");
17631 }
17632
17633 static bfd_boolean
17634 print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
17635 {
17636   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
17637   switch (pnote->type)
17638     {
17639     case NT_GNU_BUILD_ID:
17640       {
17641         unsigned long i;
17642
17643         printf (_("    Build ID: "));
17644         for (i = 0; i < pnote->descsz; ++i)
17645           printf ("%02x", pnote->descdata[i] & 0xff);
17646         printf ("\n");
17647       }
17648       break;
17649
17650     case NT_GNU_ABI_TAG:
17651       {
17652         unsigned long os, major, minor, subminor;
17653         const char *osname;
17654
17655         /* PR 17531: file: 030-599401-0.004.  */
17656         if (pnote->descsz < 16)
17657           {
17658             printf (_("    <corrupt GNU_ABI_TAG>\n"));
17659             break;
17660           }
17661
17662         os = byte_get ((unsigned char *) pnote->descdata, 4);
17663         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17664         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
17665         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
17666
17667         switch (os)
17668           {
17669           case GNU_ABI_TAG_LINUX:
17670             osname = "Linux";
17671             break;
17672           case GNU_ABI_TAG_HURD:
17673             osname = "Hurd";
17674             break;
17675           case GNU_ABI_TAG_SOLARIS:
17676             osname = "Solaris";
17677             break;
17678           case GNU_ABI_TAG_FREEBSD:
17679             osname = "FreeBSD";
17680             break;
17681           case GNU_ABI_TAG_NETBSD:
17682             osname = "NetBSD";
17683             break;
17684           case GNU_ABI_TAG_SYLLABLE:
17685             osname = "Syllable";
17686             break;
17687           case GNU_ABI_TAG_NACL:
17688             osname = "NaCl";
17689             break;
17690           default:
17691             osname = "Unknown";
17692             break;
17693           }
17694
17695         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
17696                 major, minor, subminor);
17697       }
17698       break;
17699
17700     case NT_GNU_GOLD_VERSION:
17701       {
17702         unsigned long i;
17703
17704         printf (_("    Version: "));
17705         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
17706           printf ("%c", pnote->descdata[i]);
17707         printf ("\n");
17708       }
17709       break;
17710
17711     case NT_GNU_HWCAP:
17712       {
17713         unsigned long num_entries, mask;
17714
17715         /* Hardware capabilities information.  Word 0 is the number of entries.
17716            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
17717            is a series of entries, where each entry is a single byte followed
17718            by a nul terminated string.  The byte gives the bit number to test
17719            if enabled in the bitmask.  */
17720         printf (_("      Hardware Capabilities: "));
17721         if (pnote->descsz < 8)
17722           {
17723             error (_("<corrupt GNU_HWCAP>\n"));
17724             return FALSE;
17725           }
17726         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
17727         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17728         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
17729         /* FIXME: Add code to display the entries... */
17730       }
17731       break;
17732
17733     case NT_GNU_PROPERTY_TYPE_0:
17734       print_gnu_property_note (filedata, pnote);
17735       break;
17736
17737     default:
17738       /* Handle unrecognised types.  An error message should have already been
17739          created by get_gnu_elf_note_type(), so all that we need to do is to
17740          display the data.  */
17741       {
17742         unsigned long i;
17743
17744         printf (_("    Description data: "));
17745         for (i = 0; i < pnote->descsz; ++i)
17746           printf ("%02x ", pnote->descdata[i] & 0xff);
17747         printf ("\n");
17748       }
17749       break;
17750     }
17751
17752   return TRUE;
17753 }
17754
17755 static const char *
17756 get_v850_elf_note_type (enum v850_notes n_type)
17757 {
17758   static char buff[64];
17759
17760   switch (n_type)
17761     {
17762     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
17763     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
17764     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
17765     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
17766     case V850_NOTE_CACHE_INFO: return _("Use of cache");
17767     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
17768     default:
17769       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
17770       return buff;
17771     }
17772 }
17773
17774 static bfd_boolean
17775 print_v850_note (Elf_Internal_Note * pnote)
17776 {
17777   unsigned int val;
17778
17779   if (pnote->descsz != 4)
17780     return FALSE;
17781
17782   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
17783
17784   if (val == 0)
17785     {
17786       printf (_("not set\n"));
17787       return TRUE;
17788     }
17789
17790   switch (pnote->type)
17791     {
17792     case V850_NOTE_ALIGNMENT:
17793       switch (val)
17794         {
17795         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
17796         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
17797         }
17798       break;
17799
17800     case V850_NOTE_DATA_SIZE:
17801       switch (val)
17802         {
17803         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
17804         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
17805         }
17806       break;
17807
17808     case V850_NOTE_FPU_INFO:
17809       switch (val)
17810         {
17811         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
17812         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
17813         }
17814       break;
17815
17816     case V850_NOTE_MMU_INFO:
17817     case V850_NOTE_CACHE_INFO:
17818     case V850_NOTE_SIMD_INFO:
17819       if (val == EF_RH850_SIMD)
17820         {
17821           printf (_("yes\n"));
17822           return TRUE;
17823         }
17824       break;
17825
17826     default:
17827       /* An 'unknown note type' message will already have been displayed.  */
17828       break;
17829     }
17830
17831   printf (_("unknown value: %x\n"), val);
17832   return FALSE;
17833 }
17834
17835 static bfd_boolean
17836 process_netbsd_elf_note (Elf_Internal_Note * pnote)
17837 {
17838   unsigned int version;
17839
17840   switch (pnote->type)
17841     {
17842     case NT_NETBSD_IDENT:
17843       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
17844       if ((version / 10000) % 100)
17845         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
17846                 version, version / 100000000, (version / 1000000) % 100,
17847                 (version / 10000) % 100 > 26 ? "Z" : "",
17848                 'A' + (version / 10000) % 26);
17849       else
17850         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
17851                 version, version / 100000000, (version / 1000000) % 100,
17852                 (version / 100) % 100);
17853       return TRUE;
17854
17855     case NT_NETBSD_MARCH:
17856       printf ("  NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
17857               pnote->descdata);
17858       return TRUE;
17859
17860     default:
17861       printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
17862               pnote->type);
17863       return FALSE;
17864     }
17865 }
17866
17867 static const char *
17868 get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17869 {
17870   switch (e_type)
17871     {
17872     case NT_FREEBSD_THRMISC:
17873       return _("NT_THRMISC (thrmisc structure)");
17874     case NT_FREEBSD_PROCSTAT_PROC:
17875       return _("NT_PROCSTAT_PROC (proc data)");
17876     case NT_FREEBSD_PROCSTAT_FILES:
17877       return _("NT_PROCSTAT_FILES (files data)");
17878     case NT_FREEBSD_PROCSTAT_VMMAP:
17879       return _("NT_PROCSTAT_VMMAP (vmmap data)");
17880     case NT_FREEBSD_PROCSTAT_GROUPS:
17881       return _("NT_PROCSTAT_GROUPS (groups data)");
17882     case NT_FREEBSD_PROCSTAT_UMASK:
17883       return _("NT_PROCSTAT_UMASK (umask data)");
17884     case NT_FREEBSD_PROCSTAT_RLIMIT:
17885       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17886     case NT_FREEBSD_PROCSTAT_OSREL:
17887       return _("NT_PROCSTAT_OSREL (osreldate data)");
17888     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
17889       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17890     case NT_FREEBSD_PROCSTAT_AUXV:
17891       return _("NT_PROCSTAT_AUXV (auxv data)");
17892     case NT_FREEBSD_PTLWPINFO:
17893       return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17894     }
17895   return get_note_type (filedata, e_type);
17896 }
17897
17898 static const char *
17899 get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17900 {
17901   static char buff[64];
17902
17903   if (e_type == NT_NETBSDCORE_PROCINFO)
17904     return _("NetBSD procinfo structure");
17905
17906   /* As of Jan 2002 there are no other machine-independent notes
17907      defined for NetBSD core files.  If the note type is less
17908      than the start of the machine-dependent note types, we don't
17909      understand it.  */
17910
17911   if (e_type < NT_NETBSDCORE_FIRSTMACH)
17912     {
17913       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17914       return buff;
17915     }
17916
17917   switch (filedata->file_header.e_machine)
17918     {
17919     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17920        and PT_GETFPREGS == mach+2.  */
17921
17922     case EM_OLD_ALPHA:
17923     case EM_ALPHA:
17924     case EM_SPARC:
17925     case EM_SPARC32PLUS:
17926     case EM_SPARCV9:
17927       switch (e_type)
17928         {
17929         case NT_NETBSDCORE_FIRSTMACH + 0:
17930           return _("PT_GETREGS (reg structure)");
17931         case NT_NETBSDCORE_FIRSTMACH + 2:
17932           return _("PT_GETFPREGS (fpreg structure)");
17933         default:
17934           break;
17935         }
17936       break;
17937
17938     /* On all other arch's, PT_GETREGS == mach+1 and
17939        PT_GETFPREGS == mach+3.  */
17940     default:
17941       switch (e_type)
17942         {
17943         case NT_NETBSDCORE_FIRSTMACH + 1:
17944           return _("PT_GETREGS (reg structure)");
17945         case NT_NETBSDCORE_FIRSTMACH + 3:
17946           return _("PT_GETFPREGS (fpreg structure)");
17947         default:
17948           break;
17949         }
17950     }
17951
17952   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
17953             e_type - NT_NETBSDCORE_FIRSTMACH);
17954   return buff;
17955 }
17956
17957 static const char *
17958 get_stapsdt_note_type (unsigned e_type)
17959 {
17960   static char buff[64];
17961
17962   switch (e_type)
17963     {
17964     case NT_STAPSDT:
17965       return _("NT_STAPSDT (SystemTap probe descriptors)");
17966
17967     default:
17968       break;
17969     }
17970
17971   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17972   return buff;
17973 }
17974
17975 static bfd_boolean
17976 print_stapsdt_note (Elf_Internal_Note *pnote)
17977 {
17978   size_t len, maxlen;
17979   unsigned long addr_size = is_32bit_elf ? 4 : 8;
17980   char *data = pnote->descdata;
17981   char *data_end = pnote->descdata + pnote->descsz;
17982   bfd_vma pc, base_addr, semaphore;
17983   char *provider, *probe, *arg_fmt;
17984
17985   if (pnote->descsz < (addr_size * 3))
17986     goto stapdt_note_too_small;
17987
17988   pc = byte_get ((unsigned char *) data, addr_size);
17989   data += addr_size;
17990
17991   base_addr = byte_get ((unsigned char *) data, addr_size);
17992   data += addr_size;
17993
17994   semaphore = byte_get ((unsigned char *) data, addr_size);
17995   data += addr_size;
17996
17997   if (data >= data_end)
17998     goto stapdt_note_too_small;
17999   maxlen = data_end - data;
18000   len = strnlen (data, maxlen);
18001   if (len < maxlen)
18002     {
18003       provider = data;
18004       data += len + 1;
18005     }
18006   else
18007     goto stapdt_note_too_small;
18008
18009   if (data >= data_end)
18010     goto stapdt_note_too_small;
18011   maxlen = data_end - data;
18012   len = strnlen (data, maxlen);
18013   if (len < maxlen)
18014     {
18015       probe = data;
18016       data += len + 1;
18017     }
18018   else
18019     goto stapdt_note_too_small;
18020
18021   if (data >= data_end)
18022     goto stapdt_note_too_small;
18023   maxlen = data_end - data;
18024   len = strnlen (data, maxlen);
18025   if (len < maxlen)
18026     {
18027       arg_fmt = data;
18028       data += len + 1;
18029     }
18030   else
18031     goto stapdt_note_too_small;
18032
18033   printf (_("    Provider: %s\n"), provider);
18034   printf (_("    Name: %s\n"), probe);
18035   printf (_("    Location: "));
18036   print_vma (pc, FULL_HEX);
18037   printf (_(", Base: "));
18038   print_vma (base_addr, FULL_HEX);
18039   printf (_(", Semaphore: "));
18040   print_vma (semaphore, FULL_HEX);
18041   printf ("\n");
18042   printf (_("    Arguments: %s\n"), arg_fmt);
18043
18044   return data == data_end;
18045
18046  stapdt_note_too_small:
18047   printf (_("  <corrupt - note is too small>\n"));
18048   error (_("corrupt stapdt note - the data size is too small\n"));
18049   return FALSE;
18050 }
18051
18052 static const char *
18053 get_ia64_vms_note_type (unsigned e_type)
18054 {
18055   static char buff[64];
18056
18057   switch (e_type)
18058     {
18059     case NT_VMS_MHD:
18060       return _("NT_VMS_MHD (module header)");
18061     case NT_VMS_LNM:
18062       return _("NT_VMS_LNM (language name)");
18063     case NT_VMS_SRC:
18064       return _("NT_VMS_SRC (source files)");
18065     case NT_VMS_TITLE:
18066       return "NT_VMS_TITLE";
18067     case NT_VMS_EIDC:
18068       return _("NT_VMS_EIDC (consistency check)");
18069     case NT_VMS_FPMODE:
18070       return _("NT_VMS_FPMODE (FP mode)");
18071     case NT_VMS_LINKTIME:
18072       return "NT_VMS_LINKTIME";
18073     case NT_VMS_IMGNAM:
18074       return _("NT_VMS_IMGNAM (image name)");
18075     case NT_VMS_IMGID:
18076       return _("NT_VMS_IMGID (image id)");
18077     case NT_VMS_LINKID:
18078       return _("NT_VMS_LINKID (link id)");
18079     case NT_VMS_IMGBID:
18080       return _("NT_VMS_IMGBID (build id)");
18081     case NT_VMS_GSTNAM:
18082       return _("NT_VMS_GSTNAM (sym table name)");
18083     case NT_VMS_ORIG_DYN:
18084       return "NT_VMS_ORIG_DYN";
18085     case NT_VMS_PATCHTIME:
18086       return "NT_VMS_PATCHTIME";
18087     default:
18088       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18089       return buff;
18090     }
18091 }
18092
18093 static bfd_boolean
18094 print_ia64_vms_note (Elf_Internal_Note * pnote)
18095 {
18096   int maxlen = pnote->descsz;
18097
18098   if (maxlen < 2 || (unsigned long) maxlen != pnote->descsz)
18099     goto desc_size_fail;
18100
18101   switch (pnote->type)
18102     {
18103     case NT_VMS_MHD:
18104       if (maxlen <= 36)
18105         goto desc_size_fail;
18106
18107       int l = (int) strnlen (pnote->descdata + 34, maxlen - 34);
18108
18109       printf (_("    Creation date  : %.17s\n"), pnote->descdata);
18110       printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
18111       if (l + 34 < maxlen)
18112         {
18113           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
18114           if (l + 35 < maxlen)
18115             printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
18116           else
18117             printf (_("    Module version : <missing>\n"));
18118         }
18119       else
18120         {
18121           printf (_("    Module name    : <missing>\n"));
18122           printf (_("    Module version : <missing>\n"));
18123         }
18124       break;
18125
18126     case NT_VMS_LNM:
18127       printf (_("   Language: %.*s\n"), maxlen, pnote->descdata);
18128       break;
18129
18130 #ifdef BFD64
18131     case NT_VMS_FPMODE:
18132       printf (_("   Floating Point mode: "));
18133       if (maxlen < 8)
18134         goto desc_size_fail;
18135       /* FIXME: Generate an error if descsz > 8 ?  */
18136
18137       printf ("0x%016" BFD_VMA_FMT "x\n",
18138               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
18139       break;
18140
18141     case NT_VMS_LINKTIME:
18142       printf (_("   Link time: "));
18143       if (maxlen < 8)
18144         goto desc_size_fail;
18145       /* FIXME: Generate an error if descsz > 8 ?  */
18146
18147       print_vms_time
18148         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
18149       printf ("\n");
18150       break;
18151
18152     case NT_VMS_PATCHTIME:
18153       printf (_("   Patch time: "));
18154       if (maxlen < 8)
18155         goto desc_size_fail;
18156       /* FIXME: Generate an error if descsz > 8 ?  */
18157
18158       print_vms_time
18159         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
18160       printf ("\n");
18161       break;
18162
18163     case NT_VMS_ORIG_DYN:
18164       if (maxlen < 34)
18165         goto desc_size_fail;
18166
18167       printf (_("   Major id: %u,  minor id: %u\n"),
18168               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
18169               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
18170       printf (_("   Last modified  : "));
18171       print_vms_time
18172         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
18173       printf (_("\n   Link flags  : "));
18174       printf ("0x%016" BFD_VMA_FMT "x\n",
18175               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
18176       printf (_("   Header flags: 0x%08x\n"),
18177               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
18178       printf (_("   Image id    : %.*s\n"), maxlen - 32, pnote->descdata + 32);
18179       break;
18180 #endif
18181
18182     case NT_VMS_IMGNAM:
18183       printf (_("    Image name: %.*s\n"), maxlen, pnote->descdata);
18184       break;
18185
18186     case NT_VMS_GSTNAM:
18187       printf (_("    Global symbol table name: %.*s\n"), maxlen, pnote->descdata);
18188       break;
18189
18190     case NT_VMS_IMGID:
18191       printf (_("    Image id: %.*s\n"), maxlen, pnote->descdata);
18192       break;
18193
18194     case NT_VMS_LINKID:
18195       printf (_("    Linker id: %.*s\n"), maxlen, pnote->descdata);
18196       break;
18197
18198     default:
18199       return FALSE;
18200     }
18201
18202   return TRUE;
18203
18204  desc_size_fail:
18205   printf (_("  <corrupt - data size is too small>\n"));
18206   error (_("corrupt IA64 note: data size is too small\n"));
18207   return FALSE;
18208 }
18209
18210 /* Find the symbol associated with a build attribute that is attached
18211    to address OFFSET.  If PNAME is non-NULL then store the name of
18212    the symbol (if found) in the provided pointer,  Returns NULL if a
18213    symbol could not be found.  */
18214
18215 static Elf_Internal_Sym *
18216 get_symbol_for_build_attribute (Filedata *       filedata,
18217                                 unsigned long    offset,
18218                                 bfd_boolean      is_open_attr,
18219                                 const char **    pname)
18220 {
18221   static Filedata *         saved_filedata = NULL;
18222   static char *             strtab;
18223   static unsigned long      strtablen;
18224   static Elf_Internal_Sym * symtab;
18225   static unsigned long      nsyms;
18226   Elf_Internal_Sym *        saved_sym = NULL;
18227   Elf_Internal_Sym *        sym;
18228
18229   if (filedata->section_headers != NULL
18230       && (saved_filedata == NULL || filedata != saved_filedata))
18231     {
18232       Elf_Internal_Shdr * symsec;
18233
18234       /* Load the symbol and string sections.  */
18235       for (symsec = filedata->section_headers;
18236            symsec < filedata->section_headers + filedata->file_header.e_shnum;
18237            symsec ++)
18238         {
18239           if (symsec->sh_type == SHT_SYMTAB)
18240             {
18241               symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
18242
18243               if (symsec->sh_link < filedata->file_header.e_shnum)
18244                 {
18245                   Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
18246
18247                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
18248                                               1, strtab_sec->sh_size,
18249                                               _("string table"));
18250                   strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
18251                 }
18252             }
18253         }
18254       saved_filedata = filedata;
18255     }
18256
18257   if (symtab == NULL || strtab == NULL)
18258     return NULL;
18259
18260   /* Find a symbol whose value matches offset.  */
18261   for (sym = symtab; sym < symtab + nsyms; sym ++)
18262     if (sym->st_value == offset)
18263       {
18264         if (sym->st_name >= strtablen)
18265           /* Huh ?  This should not happen.  */
18266           continue;
18267
18268         if (strtab[sym->st_name] == 0)
18269           continue;
18270
18271         /* The AArch64 and ARM architectures define mapping symbols
18272            (eg $d, $x, $t) which we want to ignore.  */
18273         if (strtab[sym->st_name] == '$'
18274             && strtab[sym->st_name + 1] != 0
18275             && strtab[sym->st_name + 2] == 0)
18276           continue;
18277
18278         if (is_open_attr)
18279           {
18280             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18281                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
18282                FUNC symbols entirely.  */
18283             switch (ELF_ST_TYPE (sym->st_info))
18284               {
18285               case STT_OBJECT:
18286               case STT_FILE:
18287                 saved_sym = sym;
18288                 if (sym->st_size)
18289                   {
18290                     /* If the symbol has a size associated
18291                        with it then we can stop searching.  */
18292                     sym = symtab + nsyms;
18293                   }
18294                 continue;
18295
18296               case STT_FUNC:
18297                 /* Ignore function symbols.  */
18298                 continue;
18299
18300               default:
18301                 break;
18302               }
18303
18304             switch (ELF_ST_BIND (sym->st_info))
18305               {
18306               case STB_GLOBAL:
18307                 if (saved_sym == NULL
18308                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
18309                   saved_sym = sym;
18310                 break;
18311
18312               case STB_LOCAL:
18313                 if (saved_sym == NULL)
18314                   saved_sym = sym;
18315                 break;
18316
18317               default:
18318                 break;
18319               }
18320           }
18321         else
18322           {
18323             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
18324               continue;
18325
18326             saved_sym = sym;
18327             break;
18328           }
18329       }
18330
18331   if (saved_sym && pname)
18332     * pname = strtab + saved_sym->st_name;
18333
18334   return saved_sym;
18335 }
18336
18337 /* Returns true iff addr1 and addr2 are in the same section.  */
18338
18339 static bfd_boolean
18340 same_section (Filedata * filedata, unsigned long addr1, unsigned long addr2)
18341 {
18342   Elf_Internal_Shdr * a1;
18343   Elf_Internal_Shdr * a2;
18344
18345   a1 = find_section_by_address (filedata, addr1);
18346   a2 = find_section_by_address (filedata, addr2);
18347
18348   return a1 == a2 && a1 != NULL;
18349 }
18350
18351 static bfd_boolean
18352 print_gnu_build_attribute_description (Elf_Internal_Note *  pnote,
18353                                        Filedata *           filedata)
18354 {
18355   static unsigned long  global_offset = 0;
18356   static unsigned long  global_end = 0;
18357   static unsigned long  func_offset = 0;
18358   static unsigned long  func_end = 0;
18359
18360   Elf_Internal_Sym *    sym;
18361   const char *          name;
18362   unsigned long         start;
18363   unsigned long         end;
18364   bfd_boolean           is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
18365
18366   switch (pnote->descsz)
18367     {
18368     case 0:
18369       /* A zero-length description means that the range of
18370          the previous note of the same type should be used.  */
18371       if (is_open_attr)
18372         {
18373           if (global_end > global_offset)
18374             printf (_("    Applies to region from %#lx to %#lx\n"),
18375                     global_offset, global_end);
18376           else
18377             printf (_("    Applies to region from %#lx\n"), global_offset);
18378         }
18379       else
18380         {
18381           if (func_end > func_offset)
18382             printf (_("    Applies to region from %#lx to %#lx\n"), func_offset, func_end);
18383           else
18384             printf (_("    Applies to region from %#lx\n"), func_offset);
18385         }
18386       return TRUE;
18387
18388     case 4:
18389       start = byte_get ((unsigned char *) pnote->descdata, 4);
18390       end = 0;
18391       break;
18392
18393     case 8:
18394       if (is_32bit_elf)
18395         {
18396           /* FIXME: We should check that version 3+ notes are being used here...  */
18397           start = byte_get ((unsigned char *) pnote->descdata, 4);
18398           end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18399         }
18400       else
18401         {
18402           start = byte_get ((unsigned char *) pnote->descdata, 8);
18403           end = 0;
18404         }
18405       break;
18406
18407     case 16:
18408       start = byte_get ((unsigned char *) pnote->descdata, 8);
18409       end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
18410       break;
18411
18412     default:
18413       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
18414       printf (_("    <invalid descsz>"));
18415       return FALSE;
18416     }
18417
18418   name = NULL;
18419   sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
18420   /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18421      in order to avoid them being confused with the start address of the
18422      first function in the file...  */
18423   if (sym == NULL && is_open_attr)
18424     sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
18425                                           & name);
18426
18427   if (end == 0 && sym != NULL && sym->st_size > 0)
18428     end = start + sym->st_size;
18429
18430   if (is_open_attr)
18431     {
18432       /* FIXME: Need to properly allow for section alignment.
18433          16 is just the alignment used on x86_64.  */
18434       if (global_end > 0
18435           && start > BFD_ALIGN (global_end, 16)
18436           /* Build notes are not guaranteed to be organised in order of
18437              increasing address, but we should find the all of the notes
18438              for one section in the same place.  */
18439           && same_section (filedata, start, global_end))
18440         warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18441               global_end + 1, start - 1);
18442
18443       printf (_("    Applies to region from %#lx"), start);
18444       global_offset = start;
18445
18446       if (end)
18447         {
18448           printf (_(" to %#lx"), end);
18449           global_end = end;
18450         }
18451     }
18452   else
18453     {
18454       printf (_("    Applies to region from %#lx"), start);
18455       func_offset = start;
18456
18457       if (end)
18458         {
18459           printf (_(" to %#lx"), end);
18460           func_end = end;
18461         }
18462     }
18463
18464   if (sym && name)
18465     printf (_(" (%s)"), name);
18466
18467   printf ("\n");
18468   return TRUE;
18469 }
18470
18471 static bfd_boolean
18472 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
18473 {
18474   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
18475   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
18476   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
18477   char         name_type;
18478   char         name_attribute;
18479   const char * expected_types;
18480   const char * name = pnote->namedata;
18481   const char * text;
18482   signed int   left;
18483
18484   if (name == NULL || pnote->namesz < 2)
18485     {
18486       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18487       print_symbol (-20, _("  <corrupt name>"));
18488       return FALSE;
18489     }
18490
18491   if (do_wide)
18492     left = 28;
18493   else
18494     left = 20;
18495
18496   /* Version 2 of the spec adds a "GA" prefix to the name field.  */
18497   if (name[0] == 'G' && name[1] == 'A')
18498     {
18499       if (pnote->namesz < 4)
18500         {
18501           error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18502           print_symbol (-20, _("  <corrupt name>"));
18503           return FALSE;
18504         }
18505
18506       printf ("GA");
18507       name += 2;
18508       left -= 2;
18509     }
18510
18511   switch ((name_type = * name))
18512     {
18513     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18514     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18515     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18516     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18517       printf ("%c", * name);
18518       left --;
18519       break;
18520     default:
18521       error (_("unrecognised attribute type in name field: %d\n"), name_type);
18522       print_symbol (-20, _("<unknown name type>"));
18523       return FALSE;
18524     }
18525
18526   ++ name;
18527   text = NULL;
18528
18529   switch ((name_attribute = * name))
18530     {
18531     case GNU_BUILD_ATTRIBUTE_VERSION:
18532       text = _("<version>");
18533       expected_types = string_expected;
18534       ++ name;
18535       break;
18536     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18537       text = _("<stack prot>");
18538       expected_types = "!+*";
18539       ++ name;
18540       break;
18541     case GNU_BUILD_ATTRIBUTE_RELRO:
18542       text = _("<relro>");
18543       expected_types = bool_expected;
18544       ++ name;
18545       break;
18546     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
18547       text = _("<stack size>");
18548       expected_types = number_expected;
18549       ++ name;
18550       break;
18551     case GNU_BUILD_ATTRIBUTE_TOOL:
18552       text = _("<tool>");
18553       expected_types = string_expected;
18554       ++ name;
18555       break;
18556     case GNU_BUILD_ATTRIBUTE_ABI:
18557       text = _("<ABI>");
18558       expected_types = "$*";
18559       ++ name;
18560       break;
18561     case GNU_BUILD_ATTRIBUTE_PIC:
18562       text = _("<PIC>");
18563       expected_types = number_expected;
18564       ++ name;
18565       break;
18566     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
18567       text = _("<short enum>");
18568       expected_types = bool_expected;
18569       ++ name;
18570       break;
18571     default:
18572       if (ISPRINT (* name))
18573         {
18574           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
18575
18576           if (len > left && ! do_wide)
18577             len = left;
18578           printf ("%.*s:", len, name);
18579           left -= len;
18580           name += len;
18581         }
18582       else
18583         {
18584           static char tmpbuf [128];
18585
18586           error (_("unrecognised byte in name field: %d\n"), * name);
18587           sprintf (tmpbuf, _("<unknown:_%d>"), * name);
18588           text = tmpbuf;
18589           name ++;
18590         }
18591       expected_types = "*$!+";
18592       break;
18593     }
18594
18595   if (text)
18596     left -= printf ("%s", text);
18597
18598   if (strchr (expected_types, name_type) == NULL)
18599     warn (_("attribute does not have an expected type (%c)\n"), name_type);
18600
18601   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
18602     {
18603       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
18604              (unsigned long) pnote->namesz,
18605              (long) (name - pnote->namedata));
18606       return FALSE;
18607     }
18608
18609   if (left < 1 && ! do_wide)
18610     return TRUE;
18611
18612   switch (name_type)
18613     {
18614     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18615       {
18616         unsigned int        bytes;
18617         unsigned long long  val = 0;
18618         unsigned int        shift = 0;
18619         char *              decoded = NULL;
18620
18621         bytes = pnote->namesz - (name - pnote->namedata);
18622         if (bytes > 0)
18623           /* The -1 is because the name field is always 0 terminated, and we
18624              want to be able to ensure that the shift in the while loop below
18625              will not overflow.  */
18626           -- bytes;
18627
18628         if (bytes > sizeof (val))
18629           {
18630             error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
18631                    bytes);
18632             bytes = sizeof (val);
18633           }
18634         /* We do not bother to warn if bytes == 0 as this can
18635            happen with some early versions of the gcc plugin.  */
18636
18637         while (bytes --)
18638           {
18639             unsigned long byte = (* name ++) & 0xff;
18640
18641             val |= byte << shift;
18642             shift += 8;
18643           }
18644
18645         switch (name_attribute)
18646           {
18647           case GNU_BUILD_ATTRIBUTE_PIC:
18648             switch (val)
18649               {
18650               case 0: decoded = "static"; break;
18651               case 1: decoded = "pic"; break;
18652               case 2: decoded = "PIC"; break;
18653               case 3: decoded = "pie"; break;
18654               case 4: decoded = "PIE"; break;
18655               default: break;
18656               }
18657             break;
18658           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18659             switch (val)
18660               {
18661                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
18662               case 0: decoded = "off"; break;
18663               case 1: decoded = "on"; break;
18664               case 2: decoded = "all"; break;
18665               case 3: decoded = "strong"; break;
18666               case 4: decoded = "explicit"; break;
18667               default: break;
18668               }
18669             break;
18670           default:
18671             break;
18672           }
18673
18674         if (decoded != NULL)
18675           {
18676             print_symbol (-left, decoded);
18677             left = 0;
18678           }
18679         else if (val == 0)
18680           {
18681             printf ("0x0");
18682             left -= 3;
18683           }
18684         else
18685           {
18686             if (do_wide)
18687               left -= printf ("0x%llx", val);
18688             else
18689               left -= printf ("0x%-.*llx", left, val);
18690           }
18691       }
18692       break;
18693     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18694       left -= print_symbol (- left, name);
18695       break;
18696     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18697       left -= print_symbol (- left, "true");
18698       break;
18699     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18700       left -= print_symbol (- left, "false");
18701       break;
18702     }
18703
18704   if (do_wide && left > 0)
18705     printf ("%-*s", left, " ");
18706
18707   return TRUE;
18708 }
18709
18710 /* Note that by the ELF standard, the name field is already null byte
18711    terminated, and namesz includes the terminating null byte.
18712    I.E. the value of namesz for the name "FSF" is 4.
18713
18714    If the value of namesz is zero, there is no name present.  */
18715
18716 static bfd_boolean
18717 process_note (Elf_Internal_Note *  pnote,
18718               Filedata *           filedata)
18719 {
18720   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
18721   const char * nt;
18722
18723   if (pnote->namesz == 0)
18724     /* If there is no note name, then use the default set of
18725        note type strings.  */
18726     nt = get_note_type (filedata, pnote->type);
18727
18728   else if (const_strneq (pnote->namedata, "GNU"))
18729     /* GNU-specific object file notes.  */
18730     nt = get_gnu_elf_note_type (pnote->type);
18731
18732   else if (const_strneq (pnote->namedata, "FreeBSD"))
18733     /* FreeBSD-specific core file notes.  */
18734     nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
18735
18736   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
18737     /* NetBSD-specific core file notes.  */
18738     nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
18739
18740   else if (const_strneq (pnote->namedata, "NetBSD"))
18741     /* NetBSD-specific core file notes.  */
18742     return process_netbsd_elf_note (pnote);
18743
18744   else if (strneq (pnote->namedata, "SPU/", 4))
18745     {
18746       /* SPU-specific core file notes.  */
18747       nt = pnote->namedata + 4;
18748       name = "SPU";
18749     }
18750
18751   else if (const_strneq (pnote->namedata, "IPF/VMS"))
18752     /* VMS/ia64-specific file notes.  */
18753     nt = get_ia64_vms_note_type (pnote->type);
18754
18755   else if (const_strneq (pnote->namedata, "stapsdt"))
18756     nt = get_stapsdt_note_type (pnote->type);
18757
18758   else
18759     /* Don't recognize this note name; just use the default set of
18760        note type strings.  */
18761     nt = get_note_type (filedata, pnote->type);
18762
18763   printf ("  ");
18764
18765   if (((const_strneq (pnote->namedata, "GA")
18766         && strchr ("*$!+", pnote->namedata[2]) != NULL)
18767        || strchr ("*$!+", pnote->namedata[0]) != NULL)
18768       && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18769           || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18770     print_gnu_build_attribute_name (pnote);
18771   else
18772     print_symbol (-20, name);
18773
18774   if (do_wide)
18775     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
18776   else
18777     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
18778
18779   if (const_strneq (pnote->namedata, "IPF/VMS"))
18780     return print_ia64_vms_note (pnote);
18781   else if (const_strneq (pnote->namedata, "GNU"))
18782     return print_gnu_note (filedata, pnote);
18783   else if (const_strneq (pnote->namedata, "stapsdt"))
18784     return print_stapsdt_note (pnote);
18785   else if (const_strneq (pnote->namedata, "CORE"))
18786     return print_core_note (pnote);
18787   else if (((const_strneq (pnote->namedata, "GA")
18788              && strchr ("*$!+", pnote->namedata[2]) != NULL)
18789             || strchr ("*$!+", pnote->namedata[0]) != NULL)
18790            && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18791                || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18792     return print_gnu_build_attribute_description (pnote, filedata);
18793
18794   if (pnote->descsz)
18795     {
18796       unsigned long i;
18797
18798       printf (_("   description data: "));
18799       for (i = 0; i < pnote->descsz; i++)
18800         printf ("%02x ", pnote->descdata[i]);
18801       if (!do_wide)
18802         printf ("\n");
18803     }
18804
18805   if (do_wide)
18806     printf ("\n");
18807
18808   return TRUE;
18809 }
18810
18811 static bfd_boolean
18812 process_notes_at (Filedata *           filedata,
18813                   Elf_Internal_Shdr *  section,
18814                   bfd_vma              offset,
18815                   bfd_vma              length,
18816                   bfd_vma              align)
18817 {
18818   Elf_External_Note * pnotes;
18819   Elf_External_Note * external;
18820   char *              end;
18821   bfd_boolean         res = TRUE;
18822
18823   if (length <= 0)
18824     return FALSE;
18825
18826   if (section)
18827     {
18828       pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
18829       if (pnotes)
18830         {
18831           if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
18832             return FALSE;
18833         }
18834     }
18835   else
18836     pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18837                                              _("notes"));
18838
18839   if (pnotes == NULL)
18840     return FALSE;
18841
18842   external = pnotes;
18843
18844   if (section)
18845     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
18846   else
18847     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18848             (unsigned long) offset, (unsigned long) length);
18849
18850   /* NB: Some note sections may have alignment value of 0 or 1.  gABI
18851      specifies that notes should be aligned to 4 bytes in 32-bit
18852      objects and to 8 bytes in 64-bit objects.  As a Linux extension,
18853      we also support 4 byte alignment in 64-bit objects.  If section
18854      alignment is less than 4, we treate alignment as 4 bytes.   */
18855   if (align < 4)
18856     align = 4;
18857   else if (align != 4 && align != 8)
18858     {
18859       warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18860             (long) align);
18861       return FALSE;
18862     }
18863
18864   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18865
18866   end = (char *) pnotes + length;
18867   while ((char *) external < end)
18868     {
18869       Elf_Internal_Note inote;
18870       size_t min_notesz;
18871       char * next;
18872       char * temp = NULL;
18873       size_t data_remaining = end - (char *) external;
18874
18875       if (!is_ia64_vms (filedata))
18876         {
18877           /* PR binutils/15191
18878              Make sure that there is enough data to read.  */
18879           min_notesz = offsetof (Elf_External_Note, name);
18880           if (data_remaining < min_notesz)
18881             {
18882               warn (ngettext ("Corrupt note: only %ld byte remains, "
18883                               "not enough for a full note\n",
18884                               "Corrupt note: only %ld bytes remain, "
18885                               "not enough for a full note\n",
18886                               data_remaining),
18887                     (long) data_remaining);
18888               break;
18889             }
18890           data_remaining -= min_notesz;
18891
18892           inote.type     = BYTE_GET (external->type);
18893           inote.namesz   = BYTE_GET (external->namesz);
18894           inote.namedata = external->name;
18895           inote.descsz   = BYTE_GET (external->descsz);
18896           inote.descdata = ((char *) external
18897                             + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
18898           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18899           next = ((char *) external
18900                   + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
18901         }
18902       else
18903         {
18904           Elf64_External_VMS_Note *vms_external;
18905
18906           /* PR binutils/15191
18907              Make sure that there is enough data to read.  */
18908           min_notesz = offsetof (Elf64_External_VMS_Note, name);
18909           if (data_remaining < min_notesz)
18910             {
18911               warn (ngettext ("Corrupt note: only %ld byte remains, "
18912                               "not enough for a full note\n",
18913                               "Corrupt note: only %ld bytes remain, "
18914                               "not enough for a full note\n",
18915                               data_remaining),
18916                     (long) data_remaining);
18917               break;
18918             }
18919           data_remaining -= min_notesz;
18920
18921           vms_external = (Elf64_External_VMS_Note *) external;
18922           inote.type     = BYTE_GET (vms_external->type);
18923           inote.namesz   = BYTE_GET (vms_external->namesz);
18924           inote.namedata = vms_external->name;
18925           inote.descsz   = BYTE_GET (vms_external->descsz);
18926           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
18927           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18928           next = inote.descdata + align_power (inote.descsz, 3);
18929         }
18930
18931       /* PR 17531: file: 3443835e.  */
18932       /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
18933       if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
18934           || (size_t) (inote.descdata - inote.namedata) > data_remaining
18935           || (size_t) (next - inote.descdata) < inote.descsz
18936           || ((size_t) (next - inote.descdata)
18937               > data_remaining - (size_t) (inote.descdata - inote.namedata)))
18938         {
18939           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18940                 (unsigned long) ((char *) external - (char *) pnotes));
18941           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18942                 inote.type, inote.namesz, inote.descsz, (int) align);
18943           break;
18944         }
18945
18946       external = (Elf_External_Note *) next;
18947
18948       /* Verify that name is null terminated.  It appears that at least
18949          one version of Linux (RedHat 6.0) generates corefiles that don't
18950          comply with the ELF spec by failing to include the null byte in
18951          namesz.  */
18952       if (inote.namesz > 0 && inote.namedata[inote.namesz - 1] != '\0')
18953         {
18954           if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
18955             {
18956               temp = (char *) malloc (inote.namesz + 1);
18957               if (temp == NULL)
18958                 {
18959                   error (_("Out of memory allocating space for inote name\n"));
18960                   res = FALSE;
18961                   break;
18962                 }
18963
18964               memcpy (temp, inote.namedata, inote.namesz);
18965               inote.namedata = temp;
18966             }
18967           inote.namedata[inote.namesz] = 0;
18968         }
18969
18970       if (! process_note (& inote, filedata))
18971         res = FALSE;
18972
18973       if (temp != NULL)
18974         {
18975           free (temp);
18976           temp = NULL;
18977         }
18978     }
18979
18980   free (pnotes);
18981
18982   return res;
18983 }
18984
18985 static bfd_boolean
18986 process_corefile_note_segments (Filedata * filedata)
18987 {
18988   Elf_Internal_Phdr * segment;
18989   unsigned int i;
18990   bfd_boolean res = TRUE;
18991
18992   if (! get_program_headers (filedata))
18993     return TRUE;
18994
18995   for (i = 0, segment = filedata->program_headers;
18996        i < filedata->file_header.e_phnum;
18997        i++, segment++)
18998     {
18999       if (segment->p_type == PT_NOTE)
19000         if (! process_notes_at (filedata, NULL,
19001                                 (bfd_vma) segment->p_offset,
19002                                 (bfd_vma) segment->p_filesz,
19003                                 (bfd_vma) segment->p_align))
19004           res = FALSE;
19005     }
19006
19007   return res;
19008 }
19009
19010 static bfd_boolean
19011 process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
19012 {
19013   Elf_External_Note * pnotes;
19014   Elf_External_Note * external;
19015   char * end;
19016   bfd_boolean res = TRUE;
19017
19018   if (length <= 0)
19019     return FALSE;
19020
19021   pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
19022                                            _("v850 notes"));
19023   if (pnotes == NULL)
19024     return FALSE;
19025
19026   external = pnotes;
19027   end = (char*) pnotes + length;
19028
19029   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19030           (unsigned long) offset, (unsigned long) length);
19031
19032   while ((char *) external + sizeof (Elf_External_Note) < end)
19033     {
19034       Elf_External_Note * next;
19035       Elf_Internal_Note inote;
19036
19037       inote.type     = BYTE_GET (external->type);
19038       inote.namesz   = BYTE_GET (external->namesz);
19039       inote.namedata = external->name;
19040       inote.descsz   = BYTE_GET (external->descsz);
19041       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
19042       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
19043
19044       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
19045         {
19046           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
19047           inote.descdata = inote.namedata;
19048           inote.namesz   = 0;
19049         }
19050
19051       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
19052
19053       if (   ((char *) next > end)
19054           || ((char *) next <  (char *) pnotes))
19055         {
19056           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19057                 (unsigned long) ((char *) external - (char *) pnotes));
19058           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19059                 inote.type, inote.namesz, inote.descsz);
19060           break;
19061         }
19062
19063       external = next;
19064
19065       /* Prevent out-of-bounds indexing.  */
19066       if (   inote.namedata + inote.namesz > end
19067           || inote.namedata + inote.namesz < inote.namedata)
19068         {
19069           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19070                 (unsigned long) ((char *) external - (char *) pnotes));
19071           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19072                 inote.type, inote.namesz, inote.descsz);
19073           break;
19074         }
19075
19076       printf ("  %s: ", get_v850_elf_note_type (inote.type));
19077
19078       if (! print_v850_note (& inote))
19079         {
19080           res = FALSE;
19081           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19082                   inote.namesz, inote.descsz);
19083         }
19084     }
19085
19086   free (pnotes);
19087
19088   return res;
19089 }
19090
19091 static bfd_boolean
19092 process_note_sections (Filedata * filedata)
19093 {
19094   Elf_Internal_Shdr * section;
19095   unsigned long i;
19096   unsigned int n = 0;
19097   bfd_boolean res = TRUE;
19098
19099   for (i = 0, section = filedata->section_headers;
19100        i < filedata->file_header.e_shnum && section != NULL;
19101        i++, section++)
19102     {
19103       if (section->sh_type == SHT_NOTE)
19104         {
19105           if (! process_notes_at (filedata, section,
19106                                   (bfd_vma) section->sh_offset,
19107                                   (bfd_vma) section->sh_size,
19108                                   (bfd_vma) section->sh_addralign))
19109             res = FALSE;
19110           n++;
19111         }
19112
19113       if ((   filedata->file_header.e_machine == EM_V800
19114            || filedata->file_header.e_machine == EM_V850
19115            || filedata->file_header.e_machine == EM_CYGNUS_V850)
19116           && section->sh_type == SHT_RENESAS_INFO)
19117         {
19118           if (! process_v850_notes (filedata,
19119                                     (bfd_vma) section->sh_offset,
19120                                     (bfd_vma) section->sh_size))
19121             res = FALSE;
19122           n++;
19123         }
19124     }
19125
19126   if (n == 0)
19127     /* Try processing NOTE segments instead.  */
19128     return process_corefile_note_segments (filedata);
19129
19130   return res;
19131 }
19132
19133 static bfd_boolean
19134 process_notes (Filedata * filedata)
19135 {
19136   /* If we have not been asked to display the notes then do nothing.  */
19137   if (! do_notes)
19138     return TRUE;
19139
19140   if (filedata->file_header.e_type != ET_CORE)
19141     return process_note_sections (filedata);
19142
19143   /* No program headers means no NOTE segment.  */
19144   if (filedata->file_header.e_phnum > 0)
19145     return process_corefile_note_segments (filedata);
19146
19147   printf (_("No note segments present in the core file.\n"));
19148   return TRUE;
19149 }
19150
19151 static unsigned char *
19152 display_public_gnu_attributes (unsigned char * start,
19153                                const unsigned char * const end)
19154 {
19155   printf (_("  Unknown GNU attribute: %s\n"), start);
19156
19157   start += strnlen ((char *) start, end - start);
19158   display_raw_attribute (start, end);
19159
19160   return (unsigned char *) end;
19161 }
19162
19163 static unsigned char *
19164 display_generic_attribute (unsigned char * start,
19165                            unsigned int tag,
19166                            const unsigned char * const end)
19167 {
19168   if (tag == 0)
19169     return (unsigned char *) end;
19170
19171   return display_tag_value (tag, start, end);
19172 }
19173
19174 static bfd_boolean
19175 process_arch_specific (Filedata * filedata)
19176 {
19177   if (! do_arch)
19178     return TRUE;
19179
19180   switch (filedata->file_header.e_machine)
19181     {
19182     case EM_ARC:
19183     case EM_ARC_COMPACT:
19184     case EM_ARC_COMPACT2:
19185       return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
19186                                  display_arc_attribute,
19187                                  display_generic_attribute);
19188     case EM_ARM:
19189       return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
19190                                  display_arm_attribute,
19191                                  display_generic_attribute);
19192
19193     case EM_MIPS:
19194     case EM_MIPS_RS3_LE:
19195       return process_mips_specific (filedata);
19196
19197     case EM_MSP430:
19198      return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
19199                                 display_msp430x_attribute,
19200                                 display_generic_attribute);
19201
19202     case EM_RISCV:
19203      return process_attributes (filedata, "riscv", SHT_RISCV_ATTRIBUTES,
19204                                 display_riscv_attribute,
19205                                 display_generic_attribute);
19206
19207     case EM_NDS32:
19208       return process_nds32_specific (filedata);
19209
19210     case EM_PPC:
19211     case EM_PPC64:
19212       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19213                                  display_power_gnu_attribute);
19214
19215     case EM_S390:
19216     case EM_S390_OLD:
19217       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19218                                  display_s390_gnu_attribute);
19219
19220     case EM_SPARC:
19221     case EM_SPARC32PLUS:
19222     case EM_SPARCV9:
19223       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19224                                  display_sparc_gnu_attribute);
19225
19226     case EM_TI_C6000:
19227       return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
19228                                  display_tic6x_attribute,
19229                                  display_generic_attribute);
19230
19231     default:
19232       return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
19233                                  display_public_gnu_attributes,
19234                                  display_generic_attribute);
19235     }
19236 }
19237
19238 static bfd_boolean
19239 get_file_header (Filedata * filedata)
19240 {
19241   /* Read in the identity array.  */
19242   if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
19243     return FALSE;
19244
19245   /* Determine how to read the rest of the header.  */
19246   switch (filedata->file_header.e_ident[EI_DATA])
19247     {
19248     default:
19249     case ELFDATANONE:
19250     case ELFDATA2LSB:
19251       byte_get = byte_get_little_endian;
19252       byte_put = byte_put_little_endian;
19253       break;
19254     case ELFDATA2MSB:
19255       byte_get = byte_get_big_endian;
19256       byte_put = byte_put_big_endian;
19257       break;
19258     }
19259
19260   /* For now we only support 32 bit and 64 bit ELF files.  */
19261   is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
19262
19263   /* Read in the rest of the header.  */
19264   if (is_32bit_elf)
19265     {
19266       Elf32_External_Ehdr ehdr32;
19267
19268       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
19269         return FALSE;
19270
19271       filedata->file_header.e_type      = BYTE_GET (ehdr32.e_type);
19272       filedata->file_header.e_machine   = BYTE_GET (ehdr32.e_machine);
19273       filedata->file_header.e_version   = BYTE_GET (ehdr32.e_version);
19274       filedata->file_header.e_entry     = BYTE_GET (ehdr32.e_entry);
19275       filedata->file_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
19276       filedata->file_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
19277       filedata->file_header.e_flags     = BYTE_GET (ehdr32.e_flags);
19278       filedata->file_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
19279       filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
19280       filedata->file_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
19281       filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
19282       filedata->file_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
19283       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
19284     }
19285   else
19286     {
19287       Elf64_External_Ehdr ehdr64;
19288
19289       /* If we have been compiled with sizeof (bfd_vma) == 4, then
19290          we will not be able to cope with the 64bit data found in
19291          64 ELF files.  Detect this now and abort before we start
19292          overwriting things.  */
19293       if (sizeof (bfd_vma) < 8)
19294         {
19295           error (_("This instance of readelf has been built without support for a\n\
19296 64 bit data type and so it cannot read 64 bit ELF files.\n"));
19297           return FALSE;
19298         }
19299
19300       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
19301         return FALSE;
19302
19303       filedata->file_header.e_type      = BYTE_GET (ehdr64.e_type);
19304       filedata->file_header.e_machine   = BYTE_GET (ehdr64.e_machine);
19305       filedata->file_header.e_version   = BYTE_GET (ehdr64.e_version);
19306       filedata->file_header.e_entry     = BYTE_GET (ehdr64.e_entry);
19307       filedata->file_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
19308       filedata->file_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
19309       filedata->file_header.e_flags     = BYTE_GET (ehdr64.e_flags);
19310       filedata->file_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
19311       filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
19312       filedata->file_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
19313       filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
19314       filedata->file_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
19315       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
19316     }
19317
19318   if (filedata->file_header.e_shoff)
19319     {
19320       /* There may be some extensions in the first section header.  Don't
19321          bomb if we can't read it.  */
19322       if (is_32bit_elf)
19323         get_32bit_section_headers (filedata, TRUE);
19324       else
19325         get_64bit_section_headers (filedata, TRUE);
19326     }
19327
19328   return TRUE;
19329 }
19330
19331 static void
19332 close_file (Filedata * filedata)
19333 {
19334   if (filedata)
19335     {
19336       if (filedata->handle)
19337         fclose (filedata->handle);
19338       free (filedata);
19339     }
19340 }
19341
19342 void
19343 close_debug_file (void * data)
19344 {
19345   close_file ((Filedata *) data);
19346 }
19347
19348 static Filedata *
19349 open_file (const char * pathname)
19350 {
19351   struct stat  statbuf;
19352   Filedata *   filedata = NULL;
19353
19354   if (stat (pathname, & statbuf) < 0
19355       || ! S_ISREG (statbuf.st_mode))
19356     goto fail;
19357
19358   filedata = calloc (1, sizeof * filedata);
19359   if (filedata == NULL)
19360     goto fail;
19361
19362   filedata->handle = fopen (pathname, "rb");
19363   if (filedata->handle == NULL)
19364     goto fail;
19365
19366   filedata->file_size = (bfd_size_type) statbuf.st_size;
19367   filedata->file_name = pathname;
19368
19369   if (! get_file_header (filedata))
19370     goto fail;
19371
19372   if (filedata->file_header.e_shoff)
19373     {
19374       bfd_boolean res;
19375
19376       /* Read the section headers again, this time for real.  */
19377       if (is_32bit_elf)
19378         res = get_32bit_section_headers (filedata, FALSE);
19379       else
19380         res = get_64bit_section_headers (filedata, FALSE);
19381
19382       if (!res)
19383         goto fail;
19384     }
19385
19386   return filedata;
19387
19388  fail:
19389   if (filedata)
19390     {
19391       if (filedata->handle)
19392         fclose (filedata->handle);
19393       free (filedata);
19394     }
19395   return NULL;
19396 }
19397
19398 void *
19399 open_debug_file (const char * pathname)
19400 {
19401   return open_file (pathname);
19402 }
19403
19404 /* Process one ELF object file according to the command line options.
19405    This file may actually be stored in an archive.  The file is
19406    positioned at the start of the ELF object.  Returns TRUE if no
19407    problems were encountered, FALSE otherwise.  */
19408
19409 static bfd_boolean
19410 process_object (Filedata * filedata)
19411 {
19412   bfd_boolean  have_separate_files;
19413   unsigned int i;
19414   bfd_boolean res = TRUE;
19415
19416   if (! get_file_header (filedata))
19417     {
19418       error (_("%s: Failed to read file header\n"), filedata->file_name);
19419       return FALSE;
19420     }
19421
19422   /* Initialise per file variables.  */
19423   for (i = ARRAY_SIZE (version_info); i--;)
19424     version_info[i] = 0;
19425
19426   for (i = ARRAY_SIZE (dynamic_info); i--;)
19427     dynamic_info[i] = 0;
19428   dynamic_info_DT_GNU_HASH = 0;
19429
19430   /* Process the file.  */
19431   if (show_name)
19432     printf (_("\nFile: %s\n"), filedata->file_name);
19433
19434   /* Initialise the dump_sects array from the cmdline_dump_sects array.
19435      Note we do this even if cmdline_dump_sects is empty because we
19436      must make sure that the dump_sets array is zeroed out before each
19437      object file is processed.  */
19438   if (filedata->num_dump_sects > cmdline.num_dump_sects)
19439     memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
19440
19441   if (cmdline.num_dump_sects > 0)
19442     {
19443       if (filedata->num_dump_sects == 0)
19444         /* A sneaky way of allocating the dump_sects array.  */
19445         request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
19446
19447       assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
19448       memcpy (filedata->dump_sects, cmdline.dump_sects,
19449               cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
19450     }
19451
19452   if (! process_file_header (filedata))
19453     return FALSE;
19454
19455   if (! process_section_headers (filedata))
19456     {
19457       /* Without loaded section headers we cannot process lots of things.  */
19458       do_unwind = do_version = do_dump = do_arch = FALSE;
19459
19460       if (! do_using_dynamic)
19461         do_syms = do_dyn_syms = do_reloc = FALSE;
19462     }
19463
19464   if (! process_section_groups (filedata))
19465     /* Without loaded section groups we cannot process unwind.  */
19466     do_unwind = FALSE;
19467
19468   if (process_program_headers (filedata))
19469     process_dynamic_section (filedata);
19470   else
19471     res = FALSE;
19472
19473   if (! process_relocs (filedata))
19474     res = FALSE;
19475
19476   if (! process_unwind (filedata))
19477     res = FALSE;
19478
19479   if (! process_symbol_table (filedata))
19480     res = FALSE;
19481
19482   if (! process_syminfo (filedata))
19483     res = FALSE;
19484
19485   if (! process_version_sections (filedata))
19486     res = FALSE;
19487
19488   if (filedata->file_header.e_shstrndx != SHN_UNDEF)
19489     have_separate_files = load_separate_debug_files (filedata, filedata->file_name);
19490   else
19491     have_separate_files = FALSE;
19492
19493   if (! process_section_contents (filedata))
19494     res = FALSE;
19495
19496   if (have_separate_files)
19497     {
19498       separate_info * d;
19499
19500       for (d = first_separate_info; d != NULL; d = d->next)
19501         {
19502           if (! process_section_headers (d->handle))
19503             res = FALSE;
19504           else if (! process_section_contents (d->handle))
19505             res = FALSE;
19506         }
19507
19508       /* The file handles are closed by the call to free_debug_memory() below.  */
19509     }
19510
19511   if (! process_notes (filedata))
19512     res = FALSE;
19513
19514   if (! process_gnu_liblist (filedata))
19515     res = FALSE;
19516
19517   if (! process_arch_specific (filedata))
19518     res = FALSE;
19519
19520   free (filedata->program_headers);
19521   filedata->program_headers = NULL;
19522
19523   free (filedata->section_headers);
19524   filedata->section_headers = NULL;
19525
19526   free (filedata->string_table);
19527   filedata->string_table = NULL;
19528   filedata->string_table_length = 0;
19529
19530   if (dynamic_strings)
19531     {
19532       free (dynamic_strings);
19533       dynamic_strings = NULL;
19534       dynamic_strings_length = 0;
19535     }
19536
19537   if (dynamic_symbols)
19538     {
19539       free (dynamic_symbols);
19540       dynamic_symbols = NULL;
19541       num_dynamic_syms = 0;
19542     }
19543
19544   if (dynamic_syminfo)
19545     {
19546       free (dynamic_syminfo);
19547       dynamic_syminfo = NULL;
19548     }
19549
19550   if (dynamic_section)
19551     {
19552       free (dynamic_section);
19553       dynamic_section = NULL;
19554     }
19555
19556   if (section_headers_groups)
19557     {
19558       free (section_headers_groups);
19559       section_headers_groups = NULL;
19560     }
19561
19562   if (section_groups)
19563     {
19564       struct group_list * g;
19565       struct group_list * next;
19566
19567       for (i = 0; i < group_count; i++)
19568         {
19569           for (g = section_groups [i].root; g != NULL; g = next)
19570             {
19571               next = g->next;
19572               free (g);
19573             }
19574         }
19575
19576       free (section_groups);
19577       section_groups = NULL;
19578     }
19579
19580   free_debug_memory ();
19581
19582   return res;
19583 }
19584
19585 /* Process an ELF archive.
19586    On entry the file is positioned just after the ARMAG string.
19587    Returns TRUE upon success, FALSE otherwise.  */
19588
19589 static bfd_boolean
19590 process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
19591 {
19592   struct archive_info arch;
19593   struct archive_info nested_arch;
19594   size_t got;
19595   bfd_boolean ret = TRUE;
19596
19597   show_name = TRUE;
19598
19599   /* The ARCH structure is used to hold information about this archive.  */
19600   arch.file_name = NULL;
19601   arch.file = NULL;
19602   arch.index_array = NULL;
19603   arch.sym_table = NULL;
19604   arch.longnames = NULL;
19605
19606   /* The NESTED_ARCH structure is used as a single-item cache of information
19607      about a nested archive (when members of a thin archive reside within
19608      another regular archive file).  */
19609   nested_arch.file_name = NULL;
19610   nested_arch.file = NULL;
19611   nested_arch.index_array = NULL;
19612   nested_arch.sym_table = NULL;
19613   nested_arch.longnames = NULL;
19614
19615   if (setup_archive (&arch, filedata->file_name, filedata->handle,
19616                      is_thin_archive, do_archive_index) != 0)
19617     {
19618       ret = FALSE;
19619       goto out;
19620     }
19621
19622   if (do_archive_index)
19623     {
19624       if (arch.sym_table == NULL)
19625         error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
19626       else
19627         {
19628           unsigned long i, l;
19629           unsigned long current_pos;
19630
19631           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
19632                   filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
19633
19634           current_pos = ftell (filedata->handle);
19635
19636           for (i = l = 0; i < arch.index_num; i++)
19637             {
19638               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
19639                 {
19640                   char * member_name;
19641
19642                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
19643
19644                   if (member_name != NULL)
19645                     {
19646                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
19647
19648                       if (qualified_name != NULL)
19649                         {
19650                           printf (_("Contents of binary %s at offset "), qualified_name);
19651                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
19652                           putchar ('\n');
19653                           free (qualified_name);
19654                         }
19655                     }
19656                 }
19657
19658               if (l >= arch.sym_size)
19659                 {
19660                   error (_("%s: end of the symbol table reached before the end of the index\n"),
19661                          filedata->file_name);
19662                   ret = FALSE;
19663                   break;
19664                 }
19665               /* PR 17531: file: 0b6630b2.  */
19666               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
19667               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
19668             }
19669
19670           if (arch.uses_64bit_indices)
19671             l = (l + 7) & ~ 7;
19672           else
19673             l += l & 1;
19674
19675           if (l < arch.sym_size)
19676             {
19677               error (ngettext ("%s: %ld byte remains in the symbol table, "
19678                                "but without corresponding entries in "
19679                                "the index table\n",
19680                                "%s: %ld bytes remain in the symbol table, "
19681                                "but without corresponding entries in "
19682                                "the index table\n",
19683                                arch.sym_size - l),
19684                      filedata->file_name, arch.sym_size - l);
19685               ret = FALSE;
19686             }
19687
19688           if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
19689             {
19690               error (_("%s: failed to seek back to start of object files in the archive\n"),
19691                      filedata->file_name);
19692               ret = FALSE;
19693               goto out;
19694             }
19695         }
19696
19697       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
19698           && !do_segments && !do_header && !do_dump && !do_version
19699           && !do_histogram && !do_debugging && !do_arch && !do_notes
19700           && !do_section_groups && !do_dyn_syms)
19701         {
19702           ret = TRUE; /* Archive index only.  */
19703           goto out;
19704         }
19705     }
19706
19707   while (1)
19708     {
19709       char * name;
19710       size_t namelen;
19711       char * qualified_name;
19712
19713       /* Read the next archive header.  */
19714       if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
19715         {
19716           error (_("%s: failed to seek to next archive header\n"), arch.file_name);
19717           return FALSE;
19718         }
19719       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
19720       if (got != sizeof arch.arhdr)
19721         {
19722           if (got == 0)
19723             break;
19724           /* PR 24049 - we cannot use filedata->file_name as this will
19725              have already been freed.  */
19726           error (_("%s: failed to read archive header\n"), arch.file_name);
19727
19728           ret = FALSE;
19729           break;
19730         }
19731       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
19732         {
19733           error (_("%s: did not find a valid archive header\n"), arch.file_name);
19734           ret = FALSE;
19735           break;
19736         }
19737
19738       arch.next_arhdr_offset += sizeof arch.arhdr;
19739
19740       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
19741       if (archive_file_size & 01)
19742         ++archive_file_size;
19743
19744       name = get_archive_member_name (&arch, &nested_arch);
19745       if (name == NULL)
19746         {
19747           error (_("%s: bad archive file name\n"), arch.file_name);
19748           ret = FALSE;
19749           break;
19750         }
19751       namelen = strlen (name);
19752
19753       qualified_name = make_qualified_name (&arch, &nested_arch, name);
19754       if (qualified_name == NULL)
19755         {
19756           error (_("%s: bad archive file name\n"), arch.file_name);
19757           ret = FALSE;
19758           break;
19759         }
19760
19761       if (is_thin_archive && arch.nested_member_origin == 0)
19762         {
19763           /* This is a proxy for an external member of a thin archive.  */
19764           Filedata * member_filedata;
19765           char * member_file_name = adjust_relative_path
19766             (filedata->file_name, name, namelen);
19767
19768           if (member_file_name == NULL)
19769             {
19770               ret = FALSE;
19771               break;
19772             }
19773
19774           member_filedata = open_file (member_file_name);
19775           if (member_filedata == NULL)
19776             {
19777               error (_("Input file '%s' is not readable.\n"), member_file_name);
19778               free (member_file_name);
19779               ret = FALSE;
19780               break;
19781             }
19782
19783           archive_file_offset = arch.nested_member_origin;
19784           member_filedata->file_name = qualified_name;
19785
19786           if (! process_object (member_filedata))
19787             ret = FALSE;
19788
19789           close_file (member_filedata);
19790           free (member_file_name);
19791         }
19792       else if (is_thin_archive)
19793         {
19794           Filedata thin_filedata;
19795
19796           memset (&thin_filedata, 0, sizeof (thin_filedata));
19797
19798           /* PR 15140: Allow for corrupt thin archives.  */
19799           if (nested_arch.file == NULL)
19800             {
19801               error (_("%s: contains corrupt thin archive: %s\n"),
19802                      qualified_name, name);
19803               ret = FALSE;
19804               break;
19805             }
19806
19807           /* This is a proxy for a member of a nested archive.  */
19808           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
19809
19810           /* The nested archive file will have been opened and setup by
19811              get_archive_member_name.  */
19812           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
19813             {
19814               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
19815               ret = FALSE;
19816               break;
19817             }
19818
19819           thin_filedata.handle = nested_arch.file;
19820           thin_filedata.file_name = qualified_name;
19821
19822           if (! process_object (& thin_filedata))
19823             ret = FALSE;
19824         }
19825       else
19826         {
19827           archive_file_offset = arch.next_arhdr_offset;
19828           arch.next_arhdr_offset += archive_file_size;
19829
19830           filedata->file_name = qualified_name;
19831           if (! process_object (filedata))
19832             ret = FALSE;
19833         }
19834
19835       if (filedata->dump_sects != NULL)
19836         {
19837           free (filedata->dump_sects);
19838           filedata->dump_sects = NULL;
19839           filedata->num_dump_sects = 0;
19840         }
19841
19842       free (qualified_name);
19843     }
19844
19845  out:
19846   if (nested_arch.file != NULL)
19847     fclose (nested_arch.file);
19848   release_archive (&nested_arch);
19849   release_archive (&arch);
19850
19851   return ret;
19852 }
19853
19854 static bfd_boolean
19855 process_file (char * file_name)
19856 {
19857   Filedata * filedata = NULL;
19858   struct stat statbuf;
19859   char armag[SARMAG];
19860   bfd_boolean ret = TRUE;
19861
19862   if (stat (file_name, &statbuf) < 0)
19863     {
19864       if (errno == ENOENT)
19865         error (_("'%s': No such file\n"), file_name);
19866       else
19867         error (_("Could not locate '%s'.  System error message: %s\n"),
19868                file_name, strerror (errno));
19869       return FALSE;
19870     }
19871
19872   if (! S_ISREG (statbuf.st_mode))
19873     {
19874       error (_("'%s' is not an ordinary file\n"), file_name);
19875       return FALSE;
19876     }
19877
19878   filedata = calloc (1, sizeof * filedata);
19879   if (filedata == NULL)
19880     {
19881       error (_("Out of memory allocating file data structure\n"));
19882       return FALSE;
19883     }
19884
19885   filedata->file_name = file_name;
19886   filedata->handle = fopen (file_name, "rb");
19887   if (filedata->handle == NULL)
19888     {
19889       error (_("Input file '%s' is not readable.\n"), file_name);
19890       free (filedata);
19891       return FALSE;
19892     }
19893
19894   if (fread (armag, SARMAG, 1, filedata->handle) != 1)
19895     {
19896       error (_("%s: Failed to read file's magic number\n"), file_name);
19897       fclose (filedata->handle);
19898       free (filedata);
19899       return FALSE;
19900     }
19901
19902   filedata->file_size = (bfd_size_type) statbuf.st_size;
19903
19904   if (memcmp (armag, ARMAG, SARMAG) == 0)
19905     {
19906       if (! process_archive (filedata, FALSE))
19907         ret = FALSE;
19908     }
19909   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
19910     {
19911       if ( ! process_archive (filedata, TRUE))
19912         ret = FALSE;
19913     }
19914   else
19915     {
19916       if (do_archive_index)
19917         error (_("File %s is not an archive so its index cannot be displayed.\n"),
19918                file_name);
19919
19920       rewind (filedata->handle);
19921       archive_file_size = archive_file_offset = 0;
19922
19923       if (! process_object (filedata))
19924         ret = FALSE;
19925     }
19926
19927   fclose (filedata->handle);
19928   free (filedata);
19929
19930   return ret;
19931 }
19932
19933 #ifdef SUPPORT_DISASSEMBLY
19934 /* Needed by the i386 disassembler.  For extra credit, someone could
19935    fix this so that we insert symbolic addresses here, esp for GOT/PLT
19936    symbols.  */
19937
19938 void
19939 print_address (unsigned int addr, FILE * outfile)
19940 {
19941   fprintf (outfile,"0x%8.8x", addr);
19942 }
19943
19944 /* Needed by the i386 disassembler.  */
19945
19946 void
19947 db_task_printsym (unsigned int addr)
19948 {
19949   print_address (addr, stderr);
19950 }
19951 #endif
19952
19953 int
19954 main (int argc, char ** argv)
19955 {
19956   int err;
19957
19958 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19959   setlocale (LC_MESSAGES, "");
19960 #endif
19961 #if defined (HAVE_SETLOCALE)
19962   setlocale (LC_CTYPE, "");
19963 #endif
19964   bindtextdomain (PACKAGE, LOCALEDIR);
19965   textdomain (PACKAGE);
19966
19967   expandargv (&argc, &argv);
19968
19969   cmdline.file_name = "<cmdline>";
19970   parse_args (& cmdline, argc, argv);
19971
19972   if (optind < (argc - 1))
19973     show_name = TRUE;
19974   else if (optind >= argc)
19975     {
19976       warn (_("Nothing to do.\n"));
19977       usage (stderr);
19978     }
19979
19980   err = FALSE;
19981   while (optind < argc)
19982     if (! process_file (argv[optind++]))
19983       err = TRUE;
19984
19985   if (cmdline.dump_sects != NULL)
19986     free (cmdline.dump_sects);
19987
19988   return err ? EXIT_FAILURE : EXIT_SUCCESS;
19989 }