binutils/readelf.c

   1 /* readelf.c -- display contents of an ELF format file
   2    Copyright (C) 1998-2018 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/d10v.h"
 102 #include "elf/d30v.h"
 103 #include "elf/dlx.h"
 104 #include "elf/epiphany.h"
 105 #include "elf/fr30.h"
 106 #include "elf/frv.h"
 107 #include "elf/ft32.h"
 108 #include "elf/h8.h"
 109 #include "elf/hppa.h"
 110 #include "elf/i386.h"
 111 #include "elf/i370.h"
 112 #include "elf/i860.h"
 113 #include "elf/i960.h"
 114 #include "elf/ia64.h"
 115 #include "elf/ip2k.h"
 116 #include "elf/lm32.h"
 117 #include "elf/iq2000.h"
 118 #include "elf/m32c.h"
 119 #include "elf/m32r.h"
 120 #include "elf/m68k.h"
 121 #include "elf/m68hc11.h"
 122 #include "elf/mcore.h"
 123 #include "elf/mep.h"
 124 #include "elf/metag.h"
 125 #include "elf/microblaze.h"
 126 #include "elf/mips.h"
 127 #include "elf/mmix.h"
 128 #include "elf/mn10200.h"
 129 #include "elf/mn10300.h"
 130 #include "elf/moxie.h"
 131 #include "elf/mt.h"
 132 #include "elf/msp430.h"
 133 #include "elf/nds32.h"
 134 #include "elf/nios2.h"
 135 #include "elf/or1k.h"
 136 #include "elf/pj.h"
 137 #include "elf/ppc.h"
 138 #include "elf/ppc64.h"
 139 #include "elf/pru.h"
 140 #include "elf/riscv.h"
 141 #include "elf/rl78.h"
 142 #include "elf/rx.h"
 143 #include "elf/s390.h"
 144 #include "elf/score.h"
 145 #include "elf/sh.h"
 146 #include "elf/sparc.h"
 147 #include "elf/spu.h"
 148 #include "elf/tic6x.h"
 149 #include "elf/tilegx.h"
 150 #include "elf/tilepro.h"
 151 #include "elf/v850.h"
 152 #include "elf/vax.h"
 153 #include "elf/visium.h"
 154 #include "elf/wasm32.h"
 155 #include "elf/x86-64.h"
 156 #include "elf/xc16x.h"
 157 #include "elf/xgate.h"
 158 #include "elf/xstormy16.h"
 159 #include "elf/xtensa.h"
 160
 161 #include "getopt.h"
 162 #include "libiberty.h"
 163 #include "safe-ctype.h"
 164 #include "filenames.h"
 165
 166 #ifndef offsetof
 167 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
 168 #endif
 169
 170 typedef struct elf_section_list
 171 {
 172   Elf_Internal_Shdr *        hdr;
 173   struct elf_section_list *  next;
 174 } elf_section_list;
 175
 176 /* Flag bits indicating particular types of dump.  */
 177 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
 178 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
 179 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
 180 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
 181 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
 182
 183 typedef unsigned char dump_type;
 184
 185 /* A linked list of the section names for which dumps were requested.  */
 186 struct dump_list_entry
 187 {
 188   char *                    name;
 189   dump_type                 type;
 190   struct dump_list_entry *  next;
 191 };
 192
 193 typedef struct filedata
 194 {
 195   const char *         file_name;
 196   FILE *               handle;
 197   bfd_size_type        file_size;
 198   Elf_Internal_Ehdr    file_header;
 199   Elf_Internal_Shdr *  section_headers;
 200   Elf_Internal_Phdr *  program_headers;
 201   char *               string_table;
 202   unsigned long        string_table_length;
 203   /* A dynamic array of flags indicating for which sections a dump of
 204      some kind has been requested.  It is reset on a per-object file
 205      basis and then initialised from the cmdline_dump_sects array,
 206      the results of interpreting the -w switch, and the
 207      dump_sects_byname list.  */
 208   dump_type *          dump_sects;
 209   unsigned int         num_dump_sects;
 210 } Filedata;
 211
 212 char * program_name = "readelf";
 213
 214 static unsigned long archive_file_offset;
 215 static unsigned long archive_file_size;
 216 static unsigned long dynamic_addr;
 217 static bfd_size_type dynamic_size;
 218 static size_t dynamic_nent;
 219 static char * dynamic_strings;
 220 static unsigned long dynamic_strings_length;
 221 static unsigned long num_dynamic_syms;
 222 static Elf_Internal_Sym * dynamic_symbols;
 223 static Elf_Internal_Syminfo * dynamic_syminfo;
 224 static unsigned long dynamic_syminfo_offset;
 225 static unsigned int dynamic_syminfo_nent;
 226 static char program_interpreter[PATH_MAX];
 227 static bfd_vma dynamic_info[DT_ENCODING];
 228 static bfd_vma dynamic_info_DT_GNU_HASH;
 229 static bfd_vma version_info[16];
 230 static Elf_Internal_Dyn *  dynamic_section;
 231 static elf_section_list * symtab_shndx_list;
 232 static bfd_boolean show_name = FALSE;
 233 static bfd_boolean do_dynamic = FALSE;
 234 static bfd_boolean do_syms = FALSE;
 235 static bfd_boolean do_dyn_syms = FALSE;
 236 static bfd_boolean do_reloc = FALSE;
 237 static bfd_boolean do_sections = FALSE;
 238 static bfd_boolean do_section_groups = FALSE;
 239 static bfd_boolean do_section_details = FALSE;
 240 static bfd_boolean do_segments = FALSE;
 241 static bfd_boolean do_unwind = FALSE;
 242 static bfd_boolean do_using_dynamic = FALSE;
 243 static bfd_boolean do_header = FALSE;
 244 static bfd_boolean do_dump = FALSE;
 245 static bfd_boolean do_version = FALSE;
 246 static bfd_boolean do_histogram = FALSE;
 247 static bfd_boolean do_debugging = FALSE;
 248 static bfd_boolean do_arch = FALSE;
 249 static bfd_boolean do_notes = FALSE;
 250 static bfd_boolean do_archive_index = FALSE;
 251 static bfd_boolean is_32bit_elf = FALSE;
 252 static bfd_boolean decompress_dumps = FALSE;
 253
 254 struct group_list
 255 {
 256   struct group_list *  next;
 257   unsigned int         section_index;
 258 };
 259
 260 struct group
 261 {
 262   struct group_list *  root;
 263   unsigned int         group_index;
 264 };
 265
 266 static size_t           group_count;
 267 static struct group *   section_groups;
 268 static struct group **  section_headers_groups;
 269
 270 /* A dynamic array of flags indicating for which sections a dump
 271    has been requested via command line switches.  */
 272 static Filedata         cmdline;
 273
 274 static struct dump_list_entry * dump_sects_byname;
 275
 276 /* How to print a vma value.  */
 277 typedef enum print_mode
 278 {
 279   HEX,
 280   DEC,
 281   DEC_5,
 282   UNSIGNED,
 283   PREFIX_HEX,
 284   FULL_HEX,
 285   LONG_HEX
 286 }
 287 print_mode;
 288
 289 /* Versioned symbol info.  */
 290 enum versioned_symbol_info
 291 {
 292   symbol_undefined,
 293   symbol_hidden,
 294   symbol_public
 295 };
 296
 297 static const char * get_symbol_version_string
 298   (Filedata *, bfd_boolean, const char *, unsigned long, unsigned,
 299    Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
 300
 301 #define UNKNOWN -1
 302
 303 #define SECTION_NAME(X)                                         \
 304   ((X) == NULL ? _("<none>")                                    \
 305    : filedata->string_table == NULL ? _("<no-strings>")         \
 306    : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>")    \
 307   : filedata->string_table + (X)->sh_name))
 308
 309 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 310
 311 #define GET_ELF_SYMBOLS(file, section, sym_count)                       \
 312   (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count)      \
 313    : get_64bit_elf_symbols (file, section, sym_count))
 314
 315 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
 316 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 317    already been called and verified that the string exists.  */
 318 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
 319
 320 #define REMOVE_ARCH_BITS(ADDR)                  \
 321   do                                            \
 322     {                                           \
 323       if (filedata->file_header.e_machine == EM_ARM)    \
 324         (ADDR) &= ~1;                           \
 325     }                                           \
 326   while (0)
 327 \f
 328 /* Print a BFD_VMA to an internal buffer, for use in error messages.
 329    BFD_FMA_FMT can't be used in translated strings.  */
 330
 331 static const char *
 332 bfd_vmatoa (char *fmtch, bfd_vma value)
 333 {
 334   /* bfd_vmatoa is used more then once in a printf call for output.
 335      Cycle through an array of buffers.  */
 336   static int buf_pos = 0;
 337   static struct bfd_vmatoa_buf
 338   {
 339     char place[64];
 340   } buf[4];
 341   char *ret;
 342   char fmt[32];
 343
 344   ret = buf[buf_pos++].place;
 345   buf_pos %= ARRAY_SIZE (buf);
 346
 347   sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch);
 348   snprintf (ret, sizeof (buf[0].place), fmt, value);
 349   return ret;
 350 }
 351
 352 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
 353    OFFSET + the offset of the current archive member, if we are examining an
 354    archive.  Put the retrieved data into VAR, if it is not NULL.  Otherwise
 355    allocate a buffer using malloc and fill that.  In either case return the
 356    pointer to the start of the retrieved data or NULL if something went wrong.
 357    If something does go wrong and REASON is not NULL then emit an error
 358    message using REASON as part of the context.  */
 359
 360 static void *
 361 get_data (void *         var,
 362           Filedata *     filedata,
 363           unsigned long  offset,
 364           bfd_size_type  size,
 365           bfd_size_type  nmemb,
 366           const char *   reason)
 367 {
 368   void * mvar;
 369   bfd_size_type amt = size * nmemb;
 370
 371   if (size == 0 || nmemb == 0)
 372     return NULL;
 373
 374   /* If the size_t type is smaller than the bfd_size_type, eg because
 375      you are building a 32-bit tool on a 64-bit host, then make sure
 376      that when the sizes are cast to (size_t) no information is lost.  */
 377   if (sizeof (size_t) < sizeof (bfd_size_type)
 378       && (   (bfd_size_type) ((size_t) size) != size
 379           || (bfd_size_type) ((size_t) nmemb) != nmemb))
 380     {
 381       if (reason)
 382         error (_("Size truncation prevents reading %s"
 383                  " elements of size %s for %s\n"),
 384                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 385       return NULL;
 386     }
 387
 388   /* Check for size overflow.  */
 389   if (amt < nmemb)
 390     {
 391       if (reason)
 392         error (_("Size overflow prevents reading %s"
 393                  " elements of size %s for %s\n"),
 394                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 395       return NULL;
 396     }
 397
 398   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
 399      attempting to allocate memory when the read is bound to fail.  */
 400   if (amt > filedata->file_size
 401       || offset + archive_file_offset + amt > filedata->file_size)
 402     {
 403       if (reason)
 404         error (_("Reading %s bytes extends past end of file for %s\n"),
 405                bfd_vmatoa ("u", amt), reason);
 406       return NULL;
 407     }
 408
 409   if (fseek (filedata->handle, archive_file_offset + offset, SEEK_SET))
 410     {
 411       if (reason)
 412         error (_("Unable to seek to 0x%lx for %s\n"),
 413                archive_file_offset + offset, reason);
 414       return NULL;
 415     }
 416
 417   mvar = var;
 418   if (mvar == NULL)
 419     {
 420       /* Check for overflow.  */
 421       if (nmemb < (~(bfd_size_type) 0 - 1) / size)
 422         /* + 1 so that we can '\0' terminate invalid string table sections.  */
 423         mvar = malloc ((size_t) amt + 1);
 424
 425       if (mvar == NULL)
 426         {
 427           if (reason)
 428             error (_("Out of memory allocating %s bytes for %s\n"),
 429                    bfd_vmatoa ("u", amt), reason);
 430           return NULL;
 431         }
 432
 433       ((char *) mvar)[amt] = '\0';
 434     }
 435
 436   if (fread (mvar, (size_t) size, (size_t) nmemb, filedata->handle) != nmemb)
 437     {
 438       if (reason)
 439         error (_("Unable to read in %s bytes of %s\n"),
 440                bfd_vmatoa ("u", amt), reason);
 441       if (mvar != var)
 442         free (mvar);
 443       return NULL;
 444     }
 445
 446   return mvar;
 447 }
 448
 449 /* Print a VMA value in the MODE specified.
 450    Returns the number of characters displayed.  */
 451
 452 static unsigned int
 453 print_vma (bfd_vma vma, print_mode mode)
 454 {
 455   unsigned int nc = 0;
 456
 457   switch (mode)
 458     {
 459     case FULL_HEX:
 460       nc = printf ("0x");
 461       /* Fall through.  */
 462     case LONG_HEX:
 463 #ifdef BFD64
 464       if (is_32bit_elf)
 465         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
 466 #endif
 467       printf_vma (vma);
 468       return nc + 16;
 469
 470     case DEC_5:
 471       if (vma <= 99999)
 472         return printf ("%5" BFD_VMA_FMT "d", vma);
 473       /* Fall through.  */
 474     case PREFIX_HEX:
 475       nc = printf ("0x");
 476       /* Fall through.  */
 477     case HEX:
 478       return nc + printf ("%" BFD_VMA_FMT "x", vma);
 479
 480     case DEC:
 481       return printf ("%" BFD_VMA_FMT "d", vma);
 482
 483     case UNSIGNED:
 484       return printf ("%" BFD_VMA_FMT "u", vma);
 485
 486     default:
 487       /* FIXME: Report unrecognised mode ?  */
 488       return 0;
 489     }
 490 }
 491
 492 /* Display a symbol on stdout.  Handles the display of control characters and
 493    multibye characters (assuming the host environment supports them).
 494
 495    Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
 496
 497    If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
 498    padding as necessary.
 499
 500    Returns the number of emitted characters.  */
 501
 502 static unsigned int
 503 print_symbol (signed int width, const char *symbol)
 504 {
 505   bfd_boolean extra_padding = FALSE;
 506   signed int num_printed = 0;
 507 #ifdef HAVE_MBSTATE_T
 508   mbstate_t state;
 509 #endif
 510   unsigned int width_remaining;
 511
 512   if (width < 0)
 513     {
 514       /* Keep the width positive.  This helps the code below.  */
 515       width = - width;
 516       extra_padding = TRUE;
 517     }
 518   assert (width != 0);
 519
 520   if (do_wide)
 521     /* Set the remaining width to a very large value.
 522        This simplifies the code below.  */
 523     width_remaining = INT_MAX;
 524   else
 525     width_remaining = width;
 526
 527 #ifdef HAVE_MBSTATE_T
 528   /* Initialise the multibyte conversion state.  */
 529   memset (& state, 0, sizeof (state));
 530 #endif
 531
 532   while (width_remaining)
 533     {
 534       size_t  n;
 535       const char c = *symbol++;
 536
 537       if (c == 0)
 538         break;
 539
 540       /* Do not print control characters directly as they can affect terminal
 541          settings.  Such characters usually appear in the names generated
 542          by the assembler for local labels.  */
 543       if (ISCNTRL (c))
 544         {
 545           if (width_remaining < 2)
 546             break;
 547
 548           printf ("^%c", c + 0x40);
 549           width_remaining -= 2;
 550           num_printed += 2;
 551         }
 552       else if (ISPRINT (c))
 553         {
 554           putchar (c);
 555           width_remaining --;
 556           num_printed ++;
 557         }
 558       else
 559         {
 560 #ifdef HAVE_MBSTATE_T
 561           wchar_t w;
 562 #endif
 563           /* Let printf do the hard work of displaying multibyte characters.  */
 564           printf ("%.1s", symbol - 1);
 565           width_remaining --;
 566           num_printed ++;
 567
 568 #ifdef HAVE_MBSTATE_T
 569           /* Try to find out how many bytes made up the character that was
 570              just printed.  Advance the symbol pointer past the bytes that
 571              were displayed.  */
 572           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 573 #else
 574           n = 1;
 575 #endif
 576           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 577             symbol += (n - 1);
 578         }
 579     }
 580
 581   if (extra_padding && num_printed < width)
 582     {
 583       /* Fill in the remaining spaces.  */
 584       printf ("%-*s", width - num_printed, " ");
 585       num_printed = width;
 586     }
 587
 588   return num_printed;
 589 }
 590
 591 /* Returns a pointer to a static buffer containing a printable version of
 592    the given section's name.  Like print_symbol, except that it does not try
 593    to print multibyte characters, it just interprets them as hex values.  */
 594
 595 static const char *
 596 printable_section_name (Filedata * filedata, const Elf_Internal_Shdr * sec)
 597 {
 598 #define MAX_PRINT_SEC_NAME_LEN 128
 599   static char  sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
 600   const char * name = SECTION_NAME (sec);
 601   char *       buf = sec_name_buf;
 602   char         c;
 603   unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
 604
 605   while ((c = * name ++) != 0)
 606     {
 607       if (ISCNTRL (c))
 608         {
 609           if (remaining < 2)
 610             break;
 611
 612           * buf ++ = '^';
 613           * buf ++ = c + 0x40;
 614           remaining -= 2;
 615         }
 616       else if (ISPRINT (c))
 617         {
 618           * buf ++ = c;
 619           remaining -= 1;
 620         }
 621       else
 622         {
 623           static char hex[17] = "0123456789ABCDEF";
 624
 625           if (remaining < 4)
 626             break;
 627           * buf ++ = '<';
 628           * buf ++ = hex[(c & 0xf0) >> 4];
 629           * buf ++ = hex[c & 0x0f];
 630           * buf ++ = '>';
 631           remaining -= 4;
 632         }
 633
 634       if (remaining == 0)
 635         break;
 636     }
 637
 638   * buf = 0;
 639   return sec_name_buf;
 640 }
 641
 642 static const char *
 643 printable_section_name_from_index (Filedata * filedata, unsigned long ndx)
 644 {
 645   if (ndx >= filedata->file_header.e_shnum)
 646     return _("<corrupt>");
 647
 648   return printable_section_name (filedata, filedata->section_headers + ndx);
 649 }
 650
 651 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 652
 653 static Elf_Internal_Shdr *
 654 find_section (Filedata * filedata, const char * name)
 655 {
 656   unsigned int i;
 657
 658   if (filedata->section_headers == NULL)
 659     return NULL;
 660
 661   for (i = 0; i < filedata->file_header.e_shnum; i++)
 662     if (streq (SECTION_NAME (filedata->section_headers + i), name))
 663       return filedata->section_headers + i;
 664
 665   return NULL;
 666 }
 667
 668 /* Return a pointer to a section containing ADDR, or NULL if no such
 669    section exists.  */
 670
 671 static Elf_Internal_Shdr *
 672 find_section_by_address (Filedata * filedata, bfd_vma addr)
 673 {
 674   unsigned int i;
 675
 676   if (filedata->section_headers == NULL)
 677     return NULL;
 678
 679   for (i = 0; i < filedata->file_header.e_shnum; i++)
 680     {
 681       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 682
 683       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 684         return sec;
 685     }
 686
 687   return NULL;
 688 }
 689
 690 static Elf_Internal_Shdr *
 691 find_section_by_type (Filedata * filedata, unsigned int type)
 692 {
 693   unsigned int i;
 694
 695   if (filedata->section_headers == NULL)
 696     return NULL;
 697
 698   for (i = 0; i < filedata->file_header.e_shnum; i++)
 699     {
 700       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 701
 702       if (sec->sh_type == type)
 703         return sec;
 704     }
 705
 706   return NULL;
 707 }
 708
 709 /* Return a pointer to section NAME, or NULL if no such section exists,
 710    restricted to the list of sections given in SET.  */
 711
 712 static Elf_Internal_Shdr *
 713 find_section_in_set (Filedata * filedata, const char * name, unsigned int * set)
 714 {
 715   unsigned int i;
 716
 717   if (filedata->section_headers == NULL)
 718     return NULL;
 719
 720   if (set != NULL)
 721     {
 722       while ((i = *set++) > 0)
 723         {
 724           /* See PR 21156 for a reproducer.  */
 725           if (i >= filedata->file_header.e_shnum)
 726             continue; /* FIXME: Should we issue an error message ?  */
 727
 728           if (streq (SECTION_NAME (filedata->section_headers + i), name))
 729             return filedata->section_headers + i;
 730         }
 731     }
 732
 733   return find_section (filedata, name);
 734 }
 735
 736 /* Read an unsigned LEB128 encoded value from DATA.
 737    Set *LENGTH_RETURN to the number of bytes read.  */
 738
 739 static inline unsigned long
 740 read_uleb128 (unsigned char * data,
 741               unsigned int * length_return,
 742               const unsigned char * const end)
 743 {
 744   return read_leb128 (data, length_return, FALSE, end);
 745 }
 746
 747 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
 748    This OS has so many departures from the ELF standard that we test it at
 749    many places.  */
 750
 751 static inline bfd_boolean
 752 is_ia64_vms (Filedata * filedata)
 753 {
 754   return filedata->file_header.e_machine == EM_IA_64
 755     && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 756 }
 757
 758 /* Guess the relocation size commonly used by the specific machines.  */
 759
 760 static bfd_boolean
 761 guess_is_rela (unsigned int e_machine)
 762 {
 763   switch (e_machine)
 764     {
 765       /* Targets that use REL relocations.  */
 766     case EM_386:
 767     case EM_IAMCU:
 768     case EM_960:
 769     case EM_ARM:
 770     case EM_D10V:
 771     case EM_CYGNUS_D10V:
 772     case EM_DLX:
 773     case EM_MIPS:
 774     case EM_MIPS_RS3_LE:
 775     case EM_CYGNUS_M32R:
 776     case EM_SCORE:
 777     case EM_XGATE:
 778       return FALSE;
 779
 780       /* Targets that use RELA relocations.  */
 781     case EM_68K:
 782     case EM_860:
 783     case EM_AARCH64:
 784     case EM_ADAPTEVA_EPIPHANY:
 785     case EM_ALPHA:
 786     case EM_ALTERA_NIOS2:
 787     case EM_ARC:
 788     case EM_ARC_COMPACT:
 789     case EM_ARC_COMPACT2:
 790     case EM_AVR:
 791     case EM_AVR_OLD:
 792     case EM_BLACKFIN:
 793     case EM_CR16:
 794     case EM_CRIS:
 795     case EM_CRX:
 796     case EM_D30V:
 797     case EM_CYGNUS_D30V:
 798     case EM_FR30:
 799     case EM_FT32:
 800     case EM_CYGNUS_FR30:
 801     case EM_CYGNUS_FRV:
 802     case EM_H8S:
 803     case EM_H8_300:
 804     case EM_H8_300H:
 805     case EM_IA_64:
 806     case EM_IP2K:
 807     case EM_IP2K_OLD:
 808     case EM_IQ2000:
 809     case EM_LATTICEMICO32:
 810     case EM_M32C_OLD:
 811     case EM_M32C:
 812     case EM_M32R:
 813     case EM_MCORE:
 814     case EM_CYGNUS_MEP:
 815     case EM_METAG:
 816     case EM_MMIX:
 817     case EM_MN10200:
 818     case EM_CYGNUS_MN10200:
 819     case EM_MN10300:
 820     case EM_CYGNUS_MN10300:
 821     case EM_MOXIE:
 822     case EM_MSP430:
 823     case EM_MSP430_OLD:
 824     case EM_MT:
 825     case EM_NDS32:
 826     case EM_NIOS32:
 827     case EM_OR1K:
 828     case EM_PPC64:
 829     case EM_PPC:
 830     case EM_TI_PRU:
 831     case EM_RISCV:
 832     case EM_RL78:
 833     case EM_RX:
 834     case EM_S390:
 835     case EM_S390_OLD:
 836     case EM_SH:
 837     case EM_SPARC:
 838     case EM_SPARC32PLUS:
 839     case EM_SPARCV9:
 840     case EM_SPU:
 841     case EM_TI_C6000:
 842     case EM_TILEGX:
 843     case EM_TILEPRO:
 844     case EM_V800:
 845     case EM_V850:
 846     case EM_CYGNUS_V850:
 847     case EM_VAX:
 848     case EM_VISIUM:
 849     case EM_X86_64:
 850     case EM_L1OM:
 851     case EM_K1OM:
 852     case EM_XSTORMY16:
 853     case EM_XTENSA:
 854     case EM_XTENSA_OLD:
 855     case EM_MICROBLAZE:
 856     case EM_MICROBLAZE_OLD:
 857     case EM_WEBASSEMBLY:
 858       return TRUE;
 859
 860     case EM_68HC05:
 861     case EM_68HC08:
 862     case EM_68HC11:
 863     case EM_68HC16:
 864     case EM_FX66:
 865     case EM_ME16:
 866     case EM_MMA:
 867     case EM_NCPU:
 868     case EM_NDR1:
 869     case EM_PCP:
 870     case EM_ST100:
 871     case EM_ST19:
 872     case EM_ST7:
 873     case EM_ST9PLUS:
 874     case EM_STARCORE:
 875     case EM_SVX:
 876     case EM_TINYJ:
 877     default:
 878       warn (_("Don't know about relocations on this machine architecture\n"));
 879       return FALSE;
 880     }
 881 }
 882
 883 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 884    Returns TRUE upon success, FALSE otherwise.  If successful then a
 885    pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
 886    and the number of relocs loaded is placed in *NRELASP.  It is the caller's
 887    responsibility to free the allocated buffer.  */
 888
 889 static bfd_boolean
 890 slurp_rela_relocs (Filedata *            filedata,
 891                    unsigned long         rel_offset,
 892                    unsigned long         rel_size,
 893                    Elf_Internal_Rela **  relasp,
 894                    unsigned long *       nrelasp)
 895 {
 896   Elf_Internal_Rela * relas;
 897   size_t nrelas;
 898   unsigned int i;
 899
 900   if (is_32bit_elf)
 901     {
 902       Elf32_External_Rela * erelas;
 903
 904       erelas = (Elf32_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 905                                                  rel_size, _("32-bit relocation data"));
 906       if (!erelas)
 907         return FALSE;
 908
 909       nrelas = rel_size / sizeof (Elf32_External_Rela);
 910
 911       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 912                                              sizeof (Elf_Internal_Rela));
 913
 914       if (relas == NULL)
 915         {
 916           free (erelas);
 917           error (_("out of memory parsing relocs\n"));
 918           return FALSE;
 919         }
 920
 921       for (i = 0; i < nrelas; i++)
 922         {
 923           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 924           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 925           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 926         }
 927
 928       free (erelas);
 929     }
 930   else
 931     {
 932       Elf64_External_Rela * erelas;
 933
 934       erelas = (Elf64_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 935                                                  rel_size, _("64-bit relocation data"));
 936       if (!erelas)
 937         return FALSE;
 938
 939       nrelas = rel_size / sizeof (Elf64_External_Rela);
 940
 941       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 942                                              sizeof (Elf_Internal_Rela));
 943
 944       if (relas == NULL)
 945         {
 946           free (erelas);
 947           error (_("out of memory parsing relocs\n"));
 948           return FALSE;
 949         }
 950
 951       for (i = 0; i < nrelas; i++)
 952         {
 953           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 954           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 955           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 956
 957           /* The #ifdef BFD64 below is to prevent a compile time
 958              warning.  We know that if we do not have a 64 bit data
 959              type that we will never execute this code anyway.  */
 960 #ifdef BFD64
 961           if (filedata->file_header.e_machine == EM_MIPS
 962               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
 963             {
 964               /* In little-endian objects, r_info isn't really a
 965                  64-bit little-endian value: it has a 32-bit
 966                  little-endian symbol index followed by four
 967                  individual byte fields.  Reorder INFO
 968                  accordingly.  */
 969               bfd_vma inf = relas[i].r_info;
 970               inf = (((inf & 0xffffffff) << 32)
 971                       | ((inf >> 56) & 0xff)
 972                       | ((inf >> 40) & 0xff00)
 973                       | ((inf >> 24) & 0xff0000)
 974                       | ((inf >> 8) & 0xff000000));
 975               relas[i].r_info = inf;
 976             }
 977 #endif /* BFD64 */
 978         }
 979
 980       free (erelas);
 981     }
 982
 983   *relasp = relas;
 984   *nrelasp = nrelas;
 985   return TRUE;
 986 }
 987
 988 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 989    Returns TRUE upon success, FALSE otherwise.  If successful then a
 990    pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
 991    and the number of relocs loaded is placed in *NRELSP.  It is the caller's
 992    responsibility to free the allocated buffer.  */
 993
 994 static bfd_boolean
 995 slurp_rel_relocs (Filedata *            filedata,
 996                   unsigned long         rel_offset,
 997                   unsigned long         rel_size,
 998                   Elf_Internal_Rela **  relsp,
 999                   unsigned long *       nrelsp)
1000 {
1001   Elf_Internal_Rela * rels;
1002   size_t nrels;
1003   unsigned int i;
1004
1005   if (is_32bit_elf)
1006     {
1007       Elf32_External_Rel * erels;
1008
1009       erels = (Elf32_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1010                                                rel_size, _("32-bit relocation data"));
1011       if (!erels)
1012         return FALSE;
1013
1014       nrels = rel_size / sizeof (Elf32_External_Rel);
1015
1016       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1017
1018       if (rels == NULL)
1019         {
1020           free (erels);
1021           error (_("out of memory parsing relocs\n"));
1022           return FALSE;
1023         }
1024
1025       for (i = 0; i < nrels; i++)
1026         {
1027           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1028           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1029           rels[i].r_addend = 0;
1030         }
1031
1032       free (erels);
1033     }
1034   else
1035     {
1036       Elf64_External_Rel * erels;
1037
1038       erels = (Elf64_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1039                                                rel_size, _("64-bit relocation data"));
1040       if (!erels)
1041         return FALSE;
1042
1043       nrels = rel_size / sizeof (Elf64_External_Rel);
1044
1045       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1046
1047       if (rels == NULL)
1048         {
1049           free (erels);
1050           error (_("out of memory parsing relocs\n"));
1051           return FALSE;
1052         }
1053
1054       for (i = 0; i < nrels; i++)
1055         {
1056           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1057           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1058           rels[i].r_addend = 0;
1059
1060           /* The #ifdef BFD64 below is to prevent a compile time
1061              warning.  We know that if we do not have a 64 bit data
1062              type that we will never execute this code anyway.  */
1063 #ifdef BFD64
1064           if (filedata->file_header.e_machine == EM_MIPS
1065               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
1066             {
1067               /* In little-endian objects, r_info isn't really a
1068                  64-bit little-endian value: it has a 32-bit
1069                  little-endian symbol index followed by four
1070                  individual byte fields.  Reorder INFO
1071                  accordingly.  */
1072               bfd_vma inf = rels[i].r_info;
1073               inf = (((inf & 0xffffffff) << 32)
1074                      | ((inf >> 56) & 0xff)
1075                      | ((inf >> 40) & 0xff00)
1076                      | ((inf >> 24) & 0xff0000)
1077                      | ((inf >> 8) & 0xff000000));
1078               rels[i].r_info = inf;
1079             }
1080 #endif /* BFD64 */
1081         }
1082
1083       free (erels);
1084     }
1085
1086   *relsp = rels;
1087   *nrelsp = nrels;
1088   return TRUE;
1089 }
1090
1091 /* Returns the reloc type extracted from the reloc info field.  */
1092
1093 static unsigned int
1094 get_reloc_type (Filedata * filedata, bfd_vma reloc_info)
1095 {
1096   if (is_32bit_elf)
1097     return ELF32_R_TYPE (reloc_info);
1098
1099   switch (filedata->file_header.e_machine)
1100     {
1101     case EM_MIPS:
1102       /* Note: We assume that reloc_info has already been adjusted for us.  */
1103       return ELF64_MIPS_R_TYPE (reloc_info);
1104
1105     case EM_SPARCV9:
1106       return ELF64_R_TYPE_ID (reloc_info);
1107
1108     default:
1109       return ELF64_R_TYPE (reloc_info);
1110     }
1111 }
1112
1113 /* Return the symbol index extracted from the reloc info field.  */
1114
1115 static bfd_vma
1116 get_reloc_symindex (bfd_vma reloc_info)
1117 {
1118   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1119 }
1120
1121 static inline bfd_boolean
1122 uses_msp430x_relocs (Filedata * filedata)
1123 {
1124   return
1125     filedata->file_header.e_machine == EM_MSP430 /* Paranoia.  */
1126     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
1127     && (((filedata->file_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1128         /* TI compiler uses ELFOSABI_NONE.  */
1129         || (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1130 }
1131
1132 /* Display the contents of the relocation data found at the specified
1133    offset.  */
1134
1135 static bfd_boolean
1136 dump_relocations (Filedata *          filedata,
1137                   unsigned long       rel_offset,
1138                   unsigned long       rel_size,
1139                   Elf_Internal_Sym *  symtab,
1140                   unsigned long       nsyms,
1141                   char *              strtab,
1142                   unsigned long       strtablen,
1143                   int                 is_rela,
1144                   bfd_boolean         is_dynsym)
1145 {
1146   unsigned long i;
1147   Elf_Internal_Rela * rels;
1148   bfd_boolean res = TRUE;
1149
1150   if (is_rela == UNKNOWN)
1151     is_rela = guess_is_rela (filedata->file_header.e_machine);
1152
1153   if (is_rela)
1154     {
1155       if (!slurp_rela_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1156         return FALSE;
1157     }
1158   else
1159     {
1160       if (!slurp_rel_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1161         return FALSE;
1162     }
1163
1164   if (is_32bit_elf)
1165     {
1166       if (is_rela)
1167         {
1168           if (do_wide)
1169             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
1170           else
1171             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
1172         }
1173       else
1174         {
1175           if (do_wide)
1176             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
1177           else
1178             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
1179         }
1180     }
1181   else
1182     {
1183       if (is_rela)
1184         {
1185           if (do_wide)
1186             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
1187           else
1188             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
1189         }
1190       else
1191         {
1192           if (do_wide)
1193             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
1194           else
1195             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
1196         }
1197     }
1198
1199   for (i = 0; i < rel_size; i++)
1200     {
1201       const char * rtype;
1202       bfd_vma offset;
1203       bfd_vma inf;
1204       bfd_vma symtab_index;
1205       bfd_vma type;
1206
1207       offset = rels[i].r_offset;
1208       inf    = rels[i].r_info;
1209
1210       type = get_reloc_type (filedata, inf);
1211       symtab_index = get_reloc_symindex  (inf);
1212
1213       if (is_32bit_elf)
1214         {
1215           printf ("%8.8lx  %8.8lx ",
1216                   (unsigned long) offset & 0xffffffff,
1217                   (unsigned long) inf & 0xffffffff);
1218         }
1219       else
1220         {
1221 #if BFD_HOST_64BIT_LONG
1222           printf (do_wide
1223                   ? "%16.16lx  %16.16lx "
1224                   : "%12.12lx  %12.12lx ",
1225                   offset, inf);
1226 #elif BFD_HOST_64BIT_LONG_LONG
1227 #ifndef __MSVCRT__
1228           printf (do_wide
1229                   ? "%16.16llx  %16.16llx "
1230                   : "%12.12llx  %12.12llx ",
1231                   offset, inf);
1232 #else
1233           printf (do_wide
1234                   ? "%16.16I64x  %16.16I64x "
1235                   : "%12.12I64x  %12.12I64x ",
1236                   offset, inf);
1237 #endif
1238 #else
1239           printf (do_wide
1240                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1241                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1242                   _bfd_int64_high (offset),
1243                   _bfd_int64_low (offset),
1244                   _bfd_int64_high (inf),
1245                   _bfd_int64_low (inf));
1246 #endif
1247         }
1248
1249       switch (filedata->file_header.e_machine)
1250         {
1251         default:
1252           rtype = NULL;
1253           break;
1254
1255         case EM_AARCH64:
1256           rtype = elf_aarch64_reloc_type (type);
1257           break;
1258
1259         case EM_M32R:
1260         case EM_CYGNUS_M32R:
1261           rtype = elf_m32r_reloc_type (type);
1262           break;
1263
1264         case EM_386:
1265         case EM_IAMCU:
1266           rtype = elf_i386_reloc_type (type);
1267           break;
1268
1269         case EM_68HC11:
1270         case EM_68HC12:
1271           rtype = elf_m68hc11_reloc_type (type);
1272           break;
1273
1274         case EM_68K:
1275           rtype = elf_m68k_reloc_type (type);
1276           break;
1277
1278         case EM_960:
1279           rtype = elf_i960_reloc_type (type);
1280           break;
1281
1282         case EM_AVR:
1283         case EM_AVR_OLD:
1284           rtype = elf_avr_reloc_type (type);
1285           break;
1286
1287         case EM_OLD_SPARCV9:
1288         case EM_SPARC32PLUS:
1289         case EM_SPARCV9:
1290         case EM_SPARC:
1291           rtype = elf_sparc_reloc_type (type);
1292           break;
1293
1294         case EM_SPU:
1295           rtype = elf_spu_reloc_type (type);
1296           break;
1297
1298         case EM_V800:
1299           rtype = v800_reloc_type (type);
1300           break;
1301         case EM_V850:
1302         case EM_CYGNUS_V850:
1303           rtype = v850_reloc_type (type);
1304           break;
1305
1306         case EM_D10V:
1307         case EM_CYGNUS_D10V:
1308           rtype = elf_d10v_reloc_type (type);
1309           break;
1310
1311         case EM_D30V:
1312         case EM_CYGNUS_D30V:
1313           rtype = elf_d30v_reloc_type (type);
1314           break;
1315
1316         case EM_DLX:
1317           rtype = elf_dlx_reloc_type (type);
1318           break;
1319
1320         case EM_SH:
1321           rtype = elf_sh_reloc_type (type);
1322           break;
1323
1324         case EM_MN10300:
1325         case EM_CYGNUS_MN10300:
1326           rtype = elf_mn10300_reloc_type (type);
1327           break;
1328
1329         case EM_MN10200:
1330         case EM_CYGNUS_MN10200:
1331           rtype = elf_mn10200_reloc_type (type);
1332           break;
1333
1334         case EM_FR30:
1335         case EM_CYGNUS_FR30:
1336           rtype = elf_fr30_reloc_type (type);
1337           break;
1338
1339         case EM_CYGNUS_FRV:
1340           rtype = elf_frv_reloc_type (type);
1341           break;
1342
1343         case EM_FT32:
1344           rtype = elf_ft32_reloc_type (type);
1345           break;
1346
1347         case EM_MCORE:
1348           rtype = elf_mcore_reloc_type (type);
1349           break;
1350
1351         case EM_MMIX:
1352           rtype = elf_mmix_reloc_type (type);
1353           break;
1354
1355         case EM_MOXIE:
1356           rtype = elf_moxie_reloc_type (type);
1357           break;
1358
1359         case EM_MSP430:
1360           if (uses_msp430x_relocs (filedata))
1361             {
1362               rtype = elf_msp430x_reloc_type (type);
1363               break;
1364             }
1365           /* Fall through.  */
1366         case EM_MSP430_OLD:
1367           rtype = elf_msp430_reloc_type (type);
1368           break;
1369
1370         case EM_NDS32:
1371           rtype = elf_nds32_reloc_type (type);
1372           break;
1373
1374         case EM_PPC:
1375           rtype = elf_ppc_reloc_type (type);
1376           break;
1377
1378         case EM_PPC64:
1379           rtype = elf_ppc64_reloc_type (type);
1380           break;
1381
1382         case EM_MIPS:
1383         case EM_MIPS_RS3_LE:
1384           rtype = elf_mips_reloc_type (type);
1385           break;
1386
1387         case EM_RISCV:
1388           rtype = elf_riscv_reloc_type (type);
1389           break;
1390
1391         case EM_ALPHA:
1392           rtype = elf_alpha_reloc_type (type);
1393           break;
1394
1395         case EM_ARM:
1396           rtype = elf_arm_reloc_type (type);
1397           break;
1398
1399         case EM_ARC:
1400         case EM_ARC_COMPACT:
1401         case EM_ARC_COMPACT2:
1402           rtype = elf_arc_reloc_type (type);
1403           break;
1404
1405         case EM_PARISC:
1406           rtype = elf_hppa_reloc_type (type);
1407           break;
1408
1409         case EM_H8_300:
1410         case EM_H8_300H:
1411         case EM_H8S:
1412           rtype = elf_h8_reloc_type (type);
1413           break;
1414
1415         case EM_OR1K:
1416           rtype = elf_or1k_reloc_type (type);
1417           break;
1418
1419         case EM_PJ:
1420         case EM_PJ_OLD:
1421           rtype = elf_pj_reloc_type (type);
1422           break;
1423         case EM_IA_64:
1424           rtype = elf_ia64_reloc_type (type);
1425           break;
1426
1427         case EM_CRIS:
1428           rtype = elf_cris_reloc_type (type);
1429           break;
1430
1431         case EM_860:
1432           rtype = elf_i860_reloc_type (type);
1433           break;
1434
1435         case EM_X86_64:
1436         case EM_L1OM:
1437         case EM_K1OM:
1438           rtype = elf_x86_64_reloc_type (type);
1439           break;
1440
1441         case EM_S370:
1442           rtype = i370_reloc_type (type);
1443           break;
1444
1445         case EM_S390_OLD:
1446         case EM_S390:
1447           rtype = elf_s390_reloc_type (type);
1448           break;
1449
1450         case EM_SCORE:
1451           rtype = elf_score_reloc_type (type);
1452           break;
1453
1454         case EM_XSTORMY16:
1455           rtype = elf_xstormy16_reloc_type (type);
1456           break;
1457
1458         case EM_CRX:
1459           rtype = elf_crx_reloc_type (type);
1460           break;
1461
1462         case EM_VAX:
1463           rtype = elf_vax_reloc_type (type);
1464           break;
1465
1466         case EM_VISIUM:
1467           rtype = elf_visium_reloc_type (type);
1468           break;
1469
1470         case EM_ADAPTEVA_EPIPHANY:
1471           rtype = elf_epiphany_reloc_type (type);
1472           break;
1473
1474         case EM_IP2K:
1475         case EM_IP2K_OLD:
1476           rtype = elf_ip2k_reloc_type (type);
1477           break;
1478
1479         case EM_IQ2000:
1480           rtype = elf_iq2000_reloc_type (type);
1481           break;
1482
1483         case EM_XTENSA_OLD:
1484         case EM_XTENSA:
1485           rtype = elf_xtensa_reloc_type (type);
1486           break;
1487
1488         case EM_LATTICEMICO32:
1489           rtype = elf_lm32_reloc_type (type);
1490           break;
1491
1492         case EM_M32C_OLD:
1493         case EM_M32C:
1494           rtype = elf_m32c_reloc_type (type);
1495           break;
1496
1497         case EM_MT:
1498           rtype = elf_mt_reloc_type (type);
1499           break;
1500
1501         case EM_BLACKFIN:
1502           rtype = elf_bfin_reloc_type (type);
1503           break;
1504
1505         case EM_CYGNUS_MEP:
1506           rtype = elf_mep_reloc_type (type);
1507           break;
1508
1509         case EM_CR16:
1510           rtype = elf_cr16_reloc_type (type);
1511           break;
1512
1513         case EM_MICROBLAZE:
1514         case EM_MICROBLAZE_OLD:
1515           rtype = elf_microblaze_reloc_type (type);
1516           break;
1517
1518         case EM_RL78:
1519           rtype = elf_rl78_reloc_type (type);
1520           break;
1521
1522         case EM_RX:
1523           rtype = elf_rx_reloc_type (type);
1524           break;
1525
1526         case EM_METAG:
1527           rtype = elf_metag_reloc_type (type);
1528           break;
1529
1530         case EM_XC16X:
1531         case EM_C166:
1532           rtype = elf_xc16x_reloc_type (type);
1533           break;
1534
1535         case EM_TI_C6000:
1536           rtype = elf_tic6x_reloc_type (type);
1537           break;
1538
1539         case EM_TILEGX:
1540           rtype = elf_tilegx_reloc_type (type);
1541           break;
1542
1543         case EM_TILEPRO:
1544           rtype = elf_tilepro_reloc_type (type);
1545           break;
1546
1547         case EM_WEBASSEMBLY:
1548           rtype = elf_wasm32_reloc_type (type);
1549           break;
1550
1551         case EM_XGATE:
1552           rtype = elf_xgate_reloc_type (type);
1553           break;
1554
1555         case EM_ALTERA_NIOS2:
1556           rtype = elf_nios2_reloc_type (type);
1557           break;
1558
1559         case EM_TI_PRU:
1560           rtype = elf_pru_reloc_type (type);
1561           break;
1562         }
1563
1564       if (rtype == NULL)
1565         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1566       else
1567         printf (do_wide ? "%-22s" : "%-17.17s", rtype);
1568
1569       if (filedata->file_header.e_machine == EM_ALPHA
1570           && rtype != NULL
1571           && streq (rtype, "R_ALPHA_LITUSE")
1572           && is_rela)
1573         {
1574           switch (rels[i].r_addend)
1575             {
1576             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1577             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1578             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1579             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1580             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1581             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1582             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1583             default: rtype = NULL;
1584             }
1585
1586           if (rtype)
1587             printf (" (%s)", rtype);
1588           else
1589             {
1590               putchar (' ');
1591               printf (_("<unknown addend: %lx>"),
1592                       (unsigned long) rels[i].r_addend);
1593               res = FALSE;
1594             }
1595         }
1596       else if (symtab_index)
1597         {
1598           if (symtab == NULL || symtab_index >= nsyms)
1599             {
1600               error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1601               res = FALSE;
1602             }
1603           else
1604             {
1605               Elf_Internal_Sym * psym;
1606               const char * version_string;
1607               enum versioned_symbol_info sym_info;
1608               unsigned short vna_other;
1609
1610               psym = symtab + symtab_index;
1611
1612               version_string
1613                 = get_symbol_version_string (filedata, is_dynsym,
1614                                              strtab, strtablen,
1615                                              symtab_index,
1616                                              psym,
1617                                              &sym_info,
1618                                              &vna_other);
1619
1620               printf (" ");
1621
1622               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1623                 {
1624                   const char * name;
1625                   unsigned int len;
1626                   unsigned int width = is_32bit_elf ? 8 : 14;
1627
1628                   /* Relocations against GNU_IFUNC symbols do not use the value
1629                      of the symbol as the address to relocate against.  Instead
1630                      they invoke the function named by the symbol and use its
1631                      result as the address for relocation.
1632
1633                      To indicate this to the user, do not display the value of
1634                      the symbol in the "Symbols's Value" field.  Instead show
1635                      its name followed by () as a hint that the symbol is
1636                      invoked.  */
1637
1638                   if (strtab == NULL
1639                       || psym->st_name == 0
1640                       || psym->st_name >= strtablen)
1641                     name = "??";
1642                   else
1643                     name = strtab + psym->st_name;
1644
1645                   len = print_symbol (width, name);
1646                   if (version_string)
1647                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1648                             version_string);
1649                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1650                 }
1651               else
1652                 {
1653                   print_vma (psym->st_value, LONG_HEX);
1654
1655                   printf (is_32bit_elf ? "   " : " ");
1656                 }
1657
1658               if (psym->st_name == 0)
1659                 {
1660                   const char * sec_name = "<null>";
1661                   char name_buf[40];
1662
1663                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1664                     {
1665                       if (psym->st_shndx < filedata->file_header.e_shnum)
1666                         sec_name = SECTION_NAME (filedata->section_headers + psym->st_shndx);
1667                       else if (psym->st_shndx == SHN_ABS)
1668                         sec_name = "ABS";
1669                       else if (psym->st_shndx == SHN_COMMON)
1670                         sec_name = "COMMON";
1671                       else if ((filedata->file_header.e_machine == EM_MIPS
1672                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1673                                || (filedata->file_header.e_machine == EM_TI_C6000
1674                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1675                         sec_name = "SCOMMON";
1676                       else if (filedata->file_header.e_machine == EM_MIPS
1677                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1678                         sec_name = "SUNDEF";
1679                       else if ((filedata->file_header.e_machine == EM_X86_64
1680                                 || filedata->file_header.e_machine == EM_L1OM
1681                                 || filedata->file_header.e_machine == EM_K1OM)
1682                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1683                         sec_name = "LARGE_COMMON";
1684                       else if (filedata->file_header.e_machine == EM_IA_64
1685                                && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1686                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1687                         sec_name = "ANSI_COM";
1688                       else if (is_ia64_vms (filedata)
1689                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1690                         sec_name = "VMS_SYMVEC";
1691                       else
1692                         {
1693                           sprintf (name_buf, "<section 0x%x>",
1694                                    (unsigned int) psym->st_shndx);
1695                           sec_name = name_buf;
1696                         }
1697                     }
1698                   print_symbol (22, sec_name);
1699                 }
1700               else if (strtab == NULL)
1701                 printf (_("<string table index: %3ld>"), psym->st_name);
1702               else if (psym->st_name >= strtablen)
1703                 {
1704                   error (_("<corrupt string table index: %3ld>"), psym->st_name);
1705                   res = FALSE;
1706                 }
1707               else
1708                 {
1709                   print_symbol (22, strtab + psym->st_name);
1710                   if (version_string)
1711                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1712                             version_string);
1713                 }
1714
1715               if (is_rela)
1716                 {
1717                   bfd_vma off = rels[i].r_addend;
1718
1719                   if ((bfd_signed_vma) off < 0)
1720                     printf (" - %" BFD_VMA_FMT "x", - off);
1721                   else
1722                     printf (" + %" BFD_VMA_FMT "x", off);
1723                 }
1724             }
1725         }
1726       else if (is_rela)
1727         {
1728           bfd_vma off = rels[i].r_addend;
1729
1730           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1731           if ((bfd_signed_vma) off < 0)
1732             printf ("-%" BFD_VMA_FMT "x", - off);
1733           else
1734             printf ("%" BFD_VMA_FMT "x", off);
1735         }
1736
1737       if (filedata->file_header.e_machine == EM_SPARCV9
1738           && rtype != NULL
1739           && streq (rtype, "R_SPARC_OLO10"))
1740         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1741
1742       putchar ('\n');
1743
1744 #ifdef BFD64
1745       if (! is_32bit_elf && filedata->file_header.e_machine == EM_MIPS)
1746         {
1747           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1748           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1749           const char * rtype2 = elf_mips_reloc_type (type2);
1750           const char * rtype3 = elf_mips_reloc_type (type3);
1751
1752           printf ("                    Type2: ");
1753
1754           if (rtype2 == NULL)
1755             printf (_("unrecognized: %-7lx"),
1756                     (unsigned long) type2 & 0xffffffff);
1757           else
1758             printf ("%-17.17s", rtype2);
1759
1760           printf ("\n                    Type3: ");
1761
1762           if (rtype3 == NULL)
1763             printf (_("unrecognized: %-7lx"),
1764                     (unsigned long) type3 & 0xffffffff);
1765           else
1766             printf ("%-17.17s", rtype3);
1767
1768           putchar ('\n');
1769         }
1770 #endif /* BFD64 */
1771     }
1772
1773   free (rels);
1774
1775   return res;
1776 }
1777
1778 static const char *
1779 get_mips_dynamic_type (unsigned long type)
1780 {
1781   switch (type)
1782     {
1783     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1784     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1785     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1786     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1787     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1788     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1789     case DT_MIPS_MSYM: return "MIPS_MSYM";
1790     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1791     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1792     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1793     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1794     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1795     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1796     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1797     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1798     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1799     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1800     case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1801     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1802     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1803     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1804     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1805     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1806     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1807     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1808     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1809     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1810     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1811     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1812     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1813     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1814     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1815     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1816     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1817     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1818     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1819     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1820     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1821     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1822     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1823     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1824     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1825     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1826     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1827     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1828     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1829     default:
1830       return NULL;
1831     }
1832 }
1833
1834 static const char *
1835 get_sparc64_dynamic_type (unsigned long type)
1836 {
1837   switch (type)
1838     {
1839     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1840     default:
1841       return NULL;
1842     }
1843 }
1844
1845 static const char *
1846 get_ppc_dynamic_type (unsigned long type)
1847 {
1848   switch (type)
1849     {
1850     case DT_PPC_GOT:    return "PPC_GOT";
1851     case DT_PPC_OPT:    return "PPC_OPT";
1852     default:
1853       return NULL;
1854     }
1855 }
1856
1857 static const char *
1858 get_ppc64_dynamic_type (unsigned long type)
1859 {
1860   switch (type)
1861     {
1862     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1863     case DT_PPC64_OPD:    return "PPC64_OPD";
1864     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1865     case DT_PPC64_OPT:    return "PPC64_OPT";
1866     default:
1867       return NULL;
1868     }
1869 }
1870
1871 static const char *
1872 get_parisc_dynamic_type (unsigned long type)
1873 {
1874   switch (type)
1875     {
1876     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1877     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1878     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1879     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1880     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1881     case DT_HP_PREINIT:         return "HP_PREINIT";
1882     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1883     case DT_HP_NEEDED:          return "HP_NEEDED";
1884     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1885     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1886     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1887     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1888     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1889     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1890     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1891     case DT_HP_FILTERED:        return "HP_FILTERED";
1892     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1893     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1894     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1895     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1896     case DT_PLT:                return "PLT";
1897     case DT_PLT_SIZE:           return "PLT_SIZE";
1898     case DT_DLT:                return "DLT";
1899     case DT_DLT_SIZE:           return "DLT_SIZE";
1900     default:
1901       return NULL;
1902     }
1903 }
1904
1905 static const char *
1906 get_ia64_dynamic_type (unsigned long type)
1907 {
1908   switch (type)
1909     {
1910     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1911     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1912     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1913     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1914     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1915     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1916     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1917     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1918     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1919     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1920     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1921     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1922     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1923     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1924     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1925     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1926     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1927     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1928     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1929     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1930     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1931     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1932     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1933     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1934     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1935     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1936     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1937     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1938     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1939     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1940     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1941     default:
1942       return NULL;
1943     }
1944 }
1945
1946 static const char *
1947 get_solaris_section_type (unsigned long type)
1948 {
1949   switch (type)
1950     {
1951     case 0x6fffffee: return "SUNW_ancillary";
1952     case 0x6fffffef: return "SUNW_capchain";
1953     case 0x6ffffff0: return "SUNW_capinfo";
1954     case 0x6ffffff1: return "SUNW_symsort";
1955     case 0x6ffffff2: return "SUNW_tlssort";
1956     case 0x6ffffff3: return "SUNW_LDYNSYM";
1957     case 0x6ffffff4: return "SUNW_dof";
1958     case 0x6ffffff5: return "SUNW_cap";
1959     case 0x6ffffff6: return "SUNW_SIGNATURE";
1960     case 0x6ffffff7: return "SUNW_ANNOTATE";
1961     case 0x6ffffff8: return "SUNW_DEBUGSTR";
1962     case 0x6ffffff9: return "SUNW_DEBUG";
1963     case 0x6ffffffa: return "SUNW_move";
1964     case 0x6ffffffb: return "SUNW_COMDAT";
1965     case 0x6ffffffc: return "SUNW_syminfo";
1966     case 0x6ffffffd: return "SUNW_verdef";
1967     case 0x6ffffffe: return "SUNW_verneed";
1968     case 0x6fffffff: return "SUNW_versym";
1969     case 0x70000000: return "SPARC_GOTDATA";
1970     default: return NULL;
1971     }
1972 }
1973
1974 static const char *
1975 get_alpha_dynamic_type (unsigned long type)
1976 {
1977   switch (type)
1978     {
1979     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1980     default: return NULL;
1981     }
1982 }
1983
1984 static const char *
1985 get_score_dynamic_type (unsigned long type)
1986 {
1987   switch (type)
1988     {
1989     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1990     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
1991     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
1992     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
1993     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
1994     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
1995     default:                    return NULL;
1996     }
1997 }
1998
1999 static const char *
2000 get_tic6x_dynamic_type (unsigned long type)
2001 {
2002   switch (type)
2003     {
2004     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
2005     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
2006     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
2007     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
2008     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
2009     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
2010     default:                   return NULL;
2011     }
2012 }
2013
2014 static const char *
2015 get_nios2_dynamic_type (unsigned long type)
2016 {
2017   switch (type)
2018     {
2019     case DT_NIOS2_GP: return "NIOS2_GP";
2020     default:          return NULL;
2021     }
2022 }
2023
2024 static const char *
2025 get_solaris_dynamic_type (unsigned long type)
2026 {
2027   switch (type)
2028     {
2029     case 0x6000000d: return "SUNW_AUXILIARY";
2030     case 0x6000000e: return "SUNW_RTLDINF";
2031     case 0x6000000f: return "SUNW_FILTER";
2032     case 0x60000010: return "SUNW_CAP";
2033     case 0x60000011: return "SUNW_SYMTAB";
2034     case 0x60000012: return "SUNW_SYMSZ";
2035     case 0x60000013: return "SUNW_SORTENT";
2036     case 0x60000014: return "SUNW_SYMSORT";
2037     case 0x60000015: return "SUNW_SYMSORTSZ";
2038     case 0x60000016: return "SUNW_TLSSORT";
2039     case 0x60000017: return "SUNW_TLSSORTSZ";
2040     case 0x60000018: return "SUNW_CAPINFO";
2041     case 0x60000019: return "SUNW_STRPAD";
2042     case 0x6000001a: return "SUNW_CAPCHAIN";
2043     case 0x6000001b: return "SUNW_LDMACH";
2044     case 0x6000001d: return "SUNW_CAPCHAINENT";
2045     case 0x6000001f: return "SUNW_CAPCHAINSZ";
2046     case 0x60000021: return "SUNW_PARENT";
2047     case 0x60000023: return "SUNW_ASLR";
2048     case 0x60000025: return "SUNW_RELAX";
2049     case 0x60000029: return "SUNW_NXHEAP";
2050     case 0x6000002b: return "SUNW_NXSTACK";
2051
2052     case 0x70000001: return "SPARC_REGISTER";
2053     case 0x7ffffffd: return "AUXILIARY";
2054     case 0x7ffffffe: return "USED";
2055     case 0x7fffffff: return "FILTER";
2056
2057     default: return NULL;
2058     }
2059 }
2060
2061 static const char *
2062 get_dynamic_type (Filedata * filedata, unsigned long type)
2063 {
2064   static char buff[64];
2065
2066   switch (type)
2067     {
2068     case DT_NULL:       return "NULL";
2069     case DT_NEEDED:     return "NEEDED";
2070     case DT_PLTRELSZ:   return "PLTRELSZ";
2071     case DT_PLTGOT:     return "PLTGOT";
2072     case DT_HASH:       return "HASH";
2073     case DT_STRTAB:     return "STRTAB";
2074     case DT_SYMTAB:     return "SYMTAB";
2075     case DT_RELA:       return "RELA";
2076     case DT_RELASZ:     return "RELASZ";
2077     case DT_RELAENT:    return "RELAENT";
2078     case DT_STRSZ:      return "STRSZ";
2079     case DT_SYMENT:     return "SYMENT";
2080     case DT_INIT:       return "INIT";
2081     case DT_FINI:       return "FINI";
2082     case DT_SONAME:     return "SONAME";
2083     case DT_RPATH:      return "RPATH";
2084     case DT_SYMBOLIC:   return "SYMBOLIC";
2085     case DT_REL:        return "REL";
2086     case DT_RELSZ:      return "RELSZ";
2087     case DT_RELENT:     return "RELENT";
2088     case DT_PLTREL:     return "PLTREL";
2089     case DT_DEBUG:      return "DEBUG";
2090     case DT_TEXTREL:    return "TEXTREL";
2091     case DT_JMPREL:     return "JMPREL";
2092     case DT_BIND_NOW:   return "BIND_NOW";
2093     case DT_INIT_ARRAY: return "INIT_ARRAY";
2094     case DT_FINI_ARRAY: return "FINI_ARRAY";
2095     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2096     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2097     case DT_RUNPATH:    return "RUNPATH";
2098     case DT_FLAGS:      return "FLAGS";
2099
2100     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2101     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2102     case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2103
2104     case DT_CHECKSUM:   return "CHECKSUM";
2105     case DT_PLTPADSZ:   return "PLTPADSZ";
2106     case DT_MOVEENT:    return "MOVEENT";
2107     case DT_MOVESZ:     return "MOVESZ";
2108     case DT_FEATURE:    return "FEATURE";
2109     case DT_POSFLAG_1:  return "POSFLAG_1";
2110     case DT_SYMINSZ:    return "SYMINSZ";
2111     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
2112
2113     case DT_ADDRRNGLO:  return "ADDRRNGLO";
2114     case DT_CONFIG:     return "CONFIG";
2115     case DT_DEPAUDIT:   return "DEPAUDIT";
2116     case DT_AUDIT:      return "AUDIT";
2117     case DT_PLTPAD:     return "PLTPAD";
2118     case DT_MOVETAB:    return "MOVETAB";
2119     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
2120
2121     case DT_VERSYM:     return "VERSYM";
2122
2123     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2124     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2125     case DT_RELACOUNT:  return "RELACOUNT";
2126     case DT_RELCOUNT:   return "RELCOUNT";
2127     case DT_FLAGS_1:    return "FLAGS_1";
2128     case DT_VERDEF:     return "VERDEF";
2129     case DT_VERDEFNUM:  return "VERDEFNUM";
2130     case DT_VERNEED:    return "VERNEED";
2131     case DT_VERNEEDNUM: return "VERNEEDNUM";
2132
2133     case DT_AUXILIARY:  return "AUXILIARY";
2134     case DT_USED:       return "USED";
2135     case DT_FILTER:     return "FILTER";
2136
2137     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2138     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2139     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2140     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2141     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2142     case DT_GNU_HASH:   return "GNU_HASH";
2143
2144     default:
2145       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2146         {
2147           const char * result;
2148
2149           switch (filedata->file_header.e_machine)
2150             {
2151             case EM_MIPS:
2152             case EM_MIPS_RS3_LE:
2153               result = get_mips_dynamic_type (type);
2154               break;
2155             case EM_SPARCV9:
2156               result = get_sparc64_dynamic_type (type);
2157               break;
2158             case EM_PPC:
2159               result = get_ppc_dynamic_type (type);
2160               break;
2161             case EM_PPC64:
2162               result = get_ppc64_dynamic_type (type);
2163               break;
2164             case EM_IA_64:
2165               result = get_ia64_dynamic_type (type);
2166               break;
2167             case EM_ALPHA:
2168               result = get_alpha_dynamic_type (type);
2169               break;
2170             case EM_SCORE:
2171               result = get_score_dynamic_type (type);
2172               break;
2173             case EM_TI_C6000:
2174               result = get_tic6x_dynamic_type (type);
2175               break;
2176             case EM_ALTERA_NIOS2:
2177               result = get_nios2_dynamic_type (type);
2178               break;
2179             default:
2180               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2181                 result = get_solaris_dynamic_type (type);
2182               else
2183                 result = NULL;
2184               break;
2185             }
2186
2187           if (result != NULL)
2188             return result;
2189
2190           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2191         }
2192       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2193                || (filedata->file_header.e_machine == EM_PARISC
2194                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2195         {
2196           const char * result;
2197
2198           switch (filedata->file_header.e_machine)
2199             {
2200             case EM_PARISC:
2201               result = get_parisc_dynamic_type (type);
2202               break;
2203             case EM_IA_64:
2204               result = get_ia64_dynamic_type (type);
2205               break;
2206             default:
2207               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2208                 result = get_solaris_dynamic_type (type);
2209               else
2210                 result = NULL;
2211               break;
2212             }
2213
2214           if (result != NULL)
2215             return result;
2216
2217           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2218                     type);
2219         }
2220       else
2221         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2222
2223       return buff;
2224     }
2225 }
2226
2227 static char *
2228 get_file_type (unsigned e_type)
2229 {
2230   static char buff[32];
2231
2232   switch (e_type)
2233     {
2234     case ET_NONE: return _("NONE (None)");
2235     case ET_REL:  return _("REL (Relocatable file)");
2236     case ET_EXEC: return _("EXEC (Executable file)");
2237     case ET_DYN:  return _("DYN (Shared object file)");
2238     case ET_CORE: return _("CORE (Core file)");
2239
2240     default:
2241       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2242         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2243       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2244         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2245       else
2246         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2247       return buff;
2248     }
2249 }
2250
2251 static char *
2252 get_machine_name (unsigned e_machine)
2253 {
2254   static char buff[64]; /* XXX */
2255
2256   switch (e_machine)
2257     {
2258       /* Please keep this switch table sorted by increasing EM_ value.  */
2259       /* 0 */
2260     case EM_NONE:               return _("None");
2261     case EM_M32:                return "WE32100";
2262     case EM_SPARC:              return "Sparc";
2263     case EM_386:                return "Intel 80386";
2264     case EM_68K:                return "MC68000";
2265     case EM_88K:                return "MC88000";
2266     case EM_IAMCU:              return "Intel MCU";
2267     case EM_860:                return "Intel 80860";
2268     case EM_MIPS:               return "MIPS R3000";
2269     case EM_S370:               return "IBM System/370";
2270       /* 10 */
2271     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
2272     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
2273     case EM_PARISC:             return "HPPA";
2274     case EM_VPP550:             return "Fujitsu VPP500";
2275     case EM_SPARC32PLUS:        return "Sparc v8+" ;
2276     case EM_960:                return "Intel 90860";
2277     case EM_PPC:                return "PowerPC";
2278       /* 20 */
2279     case EM_PPC64:              return "PowerPC64";
2280     case EM_S390_OLD:
2281     case EM_S390:               return "IBM S/390";
2282     case EM_SPU:                return "SPU";
2283       /* 30 */
2284     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
2285     case EM_FR20:               return "Fujitsu FR20";
2286     case EM_RH32:               return "TRW RH32";
2287     case EM_MCORE:              return "MCORE";
2288       /* 40 */
2289     case EM_ARM:                return "ARM";
2290     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
2291     case EM_SH:                 return "Renesas / SuperH SH";
2292     case EM_SPARCV9:            return "Sparc v9";
2293     case EM_TRICORE:            return "Siemens Tricore";
2294     case EM_ARC:                return "ARC";
2295     case EM_H8_300:             return "Renesas H8/300";
2296     case EM_H8_300H:            return "Renesas H8/300H";
2297     case EM_H8S:                return "Renesas H8S";
2298     case EM_H8_500:             return "Renesas H8/500";
2299       /* 50 */
2300     case EM_IA_64:              return "Intel IA-64";
2301     case EM_MIPS_X:             return "Stanford MIPS-X";
2302     case EM_COLDFIRE:           return "Motorola Coldfire";
2303     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
2304     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
2305     case EM_PCP:                return "Siemens PCP";
2306     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
2307     case EM_NDR1:               return "Denso NDR1 microprocesspr";
2308     case EM_STARCORE:           return "Motorola Star*Core processor";
2309     case EM_ME16:               return "Toyota ME16 processor";
2310       /* 60 */
2311     case EM_ST100:              return "STMicroelectronics ST100 processor";
2312     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
2313     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2314     case EM_PDSP:               return "Sony DSP processor";
2315     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
2316     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
2317     case EM_FX66:               return "Siemens FX66 microcontroller";
2318     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2319     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
2320     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
2321       /* 70 */
2322     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
2323     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
2324     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
2325     case EM_SVX:                return "Silicon Graphics SVx";
2326     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
2327     case EM_VAX:                return "Digital VAX";
2328     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
2329     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
2330     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2331     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2332       /* 80 */
2333     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2334     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2335     case EM_PRISM:              return "Vitesse Prism";
2336     case EM_AVR_OLD:
2337     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
2338     case EM_CYGNUS_FR30:
2339     case EM_FR30:               return "Fujitsu FR30";
2340     case EM_CYGNUS_D10V:
2341     case EM_D10V:               return "d10v";
2342     case EM_CYGNUS_D30V:
2343     case EM_D30V:               return "d30v";
2344     case EM_CYGNUS_V850:
2345     case EM_V850:               return "Renesas V850";
2346     case EM_CYGNUS_M32R:
2347     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
2348     case EM_CYGNUS_MN10300:
2349     case EM_MN10300:            return "mn10300";
2350       /* 90 */
2351     case EM_CYGNUS_MN10200:
2352     case EM_MN10200:            return "mn10200";
2353     case EM_PJ:                 return "picoJava";
2354     case EM_OR1K:               return "OpenRISC 1000";
2355     case EM_ARC_COMPACT:        return "ARCompact";
2356     case EM_XTENSA_OLD:
2357     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2358     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2359     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2360     case EM_NS32K:              return "National Semiconductor 32000 series";
2361     case EM_TPC:                return "Tenor Network TPC processor";
2362     case EM_SNP1K:              return "Trebia SNP 1000 processor";
2363       /* 100 */
2364     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2365     case EM_IP2K_OLD:
2366     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2367     case EM_MAX:                return "MAX Processor";
2368     case EM_CR:                 return "National Semiconductor CompactRISC";
2369     case EM_F2MC16:             return "Fujitsu F2MC16";
2370     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2371     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2372     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2373     case EM_SEP:                return "Sharp embedded microprocessor";
2374     case EM_ARCA:               return "Arca RISC microprocessor";
2375       /* 110 */
2376     case EM_UNICORE:            return "Unicore";
2377     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2378     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2379     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2380     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2381     case EM_XGATE:              return "Motorola XGATE embedded processor";
2382     case EM_C166:
2383     case EM_XC16X:              return "Infineon Technologies xc16x";
2384     case EM_M16C:               return "Renesas M16C series microprocessors";
2385     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2386     case EM_CE:                 return "Freescale Communication Engine RISC core";
2387       /* 120 */
2388     case EM_M32C:               return "Renesas M32c";
2389       /* 130 */
2390     case EM_TSK3000:            return "Altium TSK3000 core";
2391     case EM_RS08:               return "Freescale RS08 embedded processor";
2392     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2393     case EM_SCORE:              return "SUNPLUS S+Core";
2394     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2395     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2396     case EM_LATTICEMICO32:      return "Lattice Mico32";
2397     case EM_SE_C17:             return "Seiko Epson C17 family";
2398       /* 140 */
2399     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2400     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2401     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2402     case EM_TI_PRU:             return "TI PRU I/O processor";
2403       /* 160 */
2404     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2405     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2406     case EM_R32C:               return "Renesas R32C series microprocessors";
2407     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2408     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2409     case EM_8051:               return "Intel 8051 and variants";
2410     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2411     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2412     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2413     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2414       /* 170 */
2415     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2416     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2417     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2418     case EM_RX:                 return "Renesas RX";
2419     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2420     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2421     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2422     case EM_CR16:
2423     case EM_MICROBLAZE:
2424     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2425     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2426     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2427       /* 180 */
2428     case EM_L1OM:               return "Intel L1OM";
2429     case EM_K1OM:               return "Intel K1OM";
2430     case EM_INTEL182:           return "Intel (reserved)";
2431     case EM_AARCH64:            return "AArch64";
2432     case EM_ARM184:             return "ARM (reserved)";
2433     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor";
2434     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2435     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2436     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2437       /* 190 */
2438     case EM_CUDA:               return "NVIDIA CUDA architecture";
2439     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2440     case EM_CLOUDSHIELD:        return "CloudShield architecture family";
2441     case EM_COREA_1ST:          return "KIPO-KAIST Core-A 1st generation processor family";
2442     case EM_COREA_2ND:          return "KIPO-KAIST Core-A 2nd generation processor family";
2443     case EM_ARC_COMPACT2:       return "ARCv2";
2444     case EM_OPEN8:              return "Open8 8-bit RISC soft processor core";
2445     case EM_RL78:               return "Renesas RL78";
2446     case EM_VIDEOCORE5:         return "Broadcom VideoCore V processor";
2447     case EM_78K0R:              return "Renesas 78K0R";
2448       /* 200 */
2449     case EM_56800EX:            return "Freescale 56800EX Digital Signal Controller (DSC)";
2450     case EM_BA1:                return "Beyond BA1 CPU architecture";
2451     case EM_BA2:                return "Beyond BA2 CPU architecture";
2452     case EM_XCORE:              return "XMOS xCORE processor family";
2453     case EM_MCHP_PIC:           return "Microchip 8-bit PIC(r) family";
2454       /* 210 */
2455     case EM_KM32:               return "KM211 KM32 32-bit processor";
2456     case EM_KMX32:              return "KM211 KMX32 32-bit processor";
2457     case EM_KMX16:              return "KM211 KMX16 16-bit processor";
2458     case EM_KMX8:               return "KM211 KMX8 8-bit processor";
2459     case EM_KVARC:              return "KM211 KVARC processor";
2460     case EM_CDP:                return "Paneve CDP architecture family";
2461     case EM_COGE:               return "Cognitive Smart Memory Processor";
2462     case EM_COOL:               return "Bluechip Systems CoolEngine";
2463     case EM_NORC:               return "Nanoradio Optimized RISC";
2464     case EM_CSR_KALIMBA:        return "CSR Kalimba architecture family";
2465       /* 220 */
2466     case EM_Z80:                return "Zilog Z80";
2467     case EM_VISIUM:             return "CDS VISIUMcore processor";
2468     case EM_FT32:               return "FTDI Chip FT32";
2469     case EM_MOXIE:              return "Moxie";
2470     case EM_AMDGPU:             return "AMD GPU";
2471     case EM_RISCV:              return "RISC-V";
2472     case EM_LANAI:              return "Lanai 32-bit processor";
2473     case EM_BPF:                return "Linux BPF";
2474
2475       /* Large numbers...  */
2476     case EM_MT:                 return "Morpho Techologies MT processor";
2477     case EM_ALPHA:              return "Alpha";
2478     case EM_WEBASSEMBLY:        return "Web Assembly";
2479     case EM_DLX:                return "OpenDLX";
2480     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2481     case EM_IQ2000:             return "Vitesse IQ2000";
2482     case EM_M32C_OLD:
2483     case EM_NIOS32:             return "Altera Nios";
2484     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2485     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2486     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
2487
2488     default:
2489       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2490       return buff;
2491     }
2492 }
2493
2494 static void
2495 decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2496 {
2497   /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2.  Some
2498      other compilers don't a specific architecture type in the e_flags, and
2499      instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2500      architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2501      architectures.
2502
2503      Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2504      but also sets a specific architecture type in the e_flags field.
2505
2506      However, when decoding the flags we don't worry if we see an
2507      unexpected pairing, for example EM_ARC_COMPACT machine type, with
2508      ARCEM architecture type.  */
2509
2510   switch (e_flags & EF_ARC_MACH_MSK)
2511     {
2512       /* We only expect these to occur for EM_ARC_COMPACT2.  */
2513     case EF_ARC_CPU_ARCV2EM:
2514       strcat (buf, ", ARC EM");
2515       break;
2516     case EF_ARC_CPU_ARCV2HS:
2517       strcat (buf, ", ARC HS");
2518       break;
2519
2520       /* We only expect these to occur for EM_ARC_COMPACT.  */
2521     case E_ARC_MACH_ARC600:
2522       strcat (buf, ", ARC600");
2523       break;
2524     case E_ARC_MACH_ARC601:
2525       strcat (buf, ", ARC601");
2526       break;
2527     case E_ARC_MACH_ARC700:
2528       strcat (buf, ", ARC700");
2529       break;
2530
2531       /* The only times we should end up here are (a) A corrupt ELF, (b) A
2532          new ELF with new architecture being read by an old version of
2533          readelf, or (c) An ELF built with non-GNU compiler that does not
2534          set the architecture in the e_flags.  */
2535     default:
2536       if (e_machine == EM_ARC_COMPACT)
2537         strcat (buf, ", Unknown ARCompact");
2538       else
2539         strcat (buf, ", Unknown ARC");
2540       break;
2541     }
2542
2543   switch (e_flags & EF_ARC_OSABI_MSK)
2544     {
2545     case E_ARC_OSABI_ORIG:
2546       strcat (buf, ", (ABI:legacy)");
2547       break;
2548     case E_ARC_OSABI_V2:
2549       strcat (buf, ", (ABI:v2)");
2550       break;
2551       /* Only upstream 3.9+ kernels will support ARCv2 ISA.  */
2552     case E_ARC_OSABI_V3:
2553       strcat (buf, ", v3 no-legacy-syscalls ABI");
2554       break;
2555     case E_ARC_OSABI_V4:
2556       strcat (buf, ", v4 ABI");
2557       break;
2558     default:
2559       strcat (buf, ", unrecognised ARC OSABI flag");
2560       break;
2561     }
2562 }
2563
2564 static void
2565 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2566 {
2567   unsigned eabi;
2568   bfd_boolean unknown = FALSE;
2569
2570   eabi = EF_ARM_EABI_VERSION (e_flags);
2571   e_flags &= ~ EF_ARM_EABIMASK;
2572
2573   /* Handle "generic" ARM flags.  */
2574   if (e_flags & EF_ARM_RELEXEC)
2575     {
2576       strcat (buf, ", relocatable executable");
2577       e_flags &= ~ EF_ARM_RELEXEC;
2578     }
2579
2580   /* Now handle EABI specific flags.  */
2581   switch (eabi)
2582     {
2583     default:
2584       strcat (buf, ", <unrecognized EABI>");
2585       if (e_flags)
2586         unknown = TRUE;
2587       break;
2588
2589     case EF_ARM_EABI_VER1:
2590       strcat (buf, ", Version1 EABI");
2591       while (e_flags)
2592         {
2593           unsigned flag;
2594
2595           /* Process flags one bit at a time.  */
2596           flag = e_flags & - e_flags;
2597           e_flags &= ~ flag;
2598
2599           switch (flag)
2600             {
2601             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2602               strcat (buf, ", sorted symbol tables");
2603               break;
2604
2605             default:
2606               unknown = TRUE;
2607               break;
2608             }
2609         }
2610       break;
2611
2612     case EF_ARM_EABI_VER2:
2613       strcat (buf, ", Version2 EABI");
2614       while (e_flags)
2615         {
2616           unsigned flag;
2617
2618           /* Process flags one bit at a time.  */
2619           flag = e_flags & - e_flags;
2620           e_flags &= ~ flag;
2621
2622           switch (flag)
2623             {
2624             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2625               strcat (buf, ", sorted symbol tables");
2626               break;
2627
2628             case EF_ARM_DYNSYMSUSESEGIDX:
2629               strcat (buf, ", dynamic symbols use segment index");
2630               break;
2631
2632             case EF_ARM_MAPSYMSFIRST:
2633               strcat (buf, ", mapping symbols precede others");
2634               break;
2635
2636             default:
2637               unknown = TRUE;
2638               break;
2639             }
2640         }
2641       break;
2642
2643     case EF_ARM_EABI_VER3:
2644       strcat (buf, ", Version3 EABI");
2645       break;
2646
2647     case EF_ARM_EABI_VER4:
2648       strcat (buf, ", Version4 EABI");
2649       while (e_flags)
2650         {
2651           unsigned flag;
2652
2653           /* Process flags one bit at a time.  */
2654           flag = e_flags & - e_flags;
2655           e_flags &= ~ flag;
2656
2657           switch (flag)
2658             {
2659             case EF_ARM_BE8:
2660               strcat (buf, ", BE8");
2661               break;
2662
2663             case EF_ARM_LE8:
2664               strcat (buf, ", LE8");
2665               break;
2666
2667             default:
2668               unknown = TRUE;
2669               break;
2670             }
2671         }
2672       break;
2673
2674     case EF_ARM_EABI_VER5:
2675       strcat (buf, ", Version5 EABI");
2676       while (e_flags)
2677         {
2678           unsigned flag;
2679
2680           /* Process flags one bit at a time.  */
2681           flag = e_flags & - e_flags;
2682           e_flags &= ~ flag;
2683
2684           switch (flag)
2685             {
2686             case EF_ARM_BE8:
2687               strcat (buf, ", BE8");
2688               break;
2689
2690             case EF_ARM_LE8:
2691               strcat (buf, ", LE8");
2692               break;
2693
2694             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2695               strcat (buf, ", soft-float ABI");
2696               break;
2697
2698             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2699               strcat (buf, ", hard-float ABI");
2700               break;
2701
2702             default:
2703               unknown = TRUE;
2704               break;
2705             }
2706         }
2707       break;
2708
2709     case EF_ARM_EABI_UNKNOWN:
2710       strcat (buf, ", GNU EABI");
2711       while (e_flags)
2712         {
2713           unsigned flag;
2714
2715           /* Process flags one bit at a time.  */
2716           flag = e_flags & - e_flags;
2717           e_flags &= ~ flag;
2718
2719           switch (flag)
2720             {
2721             case EF_ARM_INTERWORK:
2722               strcat (buf, ", interworking enabled");
2723               break;
2724
2725             case EF_ARM_APCS_26:
2726               strcat (buf, ", uses APCS/26");
2727               break;
2728
2729             case EF_ARM_APCS_FLOAT:
2730               strcat (buf, ", uses APCS/float");
2731               break;
2732
2733             case EF_ARM_PIC:
2734               strcat (buf, ", position independent");
2735               break;
2736
2737             case EF_ARM_ALIGN8:
2738               strcat (buf, ", 8 bit structure alignment");
2739               break;
2740
2741             case EF_ARM_NEW_ABI:
2742               strcat (buf, ", uses new ABI");
2743               break;
2744
2745             case EF_ARM_OLD_ABI:
2746               strcat (buf, ", uses old ABI");
2747               break;
2748
2749             case EF_ARM_SOFT_FLOAT:
2750               strcat (buf, ", software FP");
2751               break;
2752
2753             case EF_ARM_VFP_FLOAT:
2754               strcat (buf, ", VFP");
2755               break;
2756
2757             case EF_ARM_MAVERICK_FLOAT:
2758               strcat (buf, ", Maverick FP");
2759               break;
2760
2761             default:
2762               unknown = TRUE;
2763               break;
2764             }
2765         }
2766     }
2767
2768   if (unknown)
2769     strcat (buf,_(", <unknown>"));
2770 }
2771
2772 static void
2773 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2774 {
2775   --size; /* Leave space for null terminator.  */
2776
2777   switch (e_flags & EF_AVR_MACH)
2778     {
2779     case E_AVR_MACH_AVR1:
2780       strncat (buf, ", avr:1", size);
2781       break;
2782     case E_AVR_MACH_AVR2:
2783       strncat (buf, ", avr:2", size);
2784       break;
2785     case E_AVR_MACH_AVR25:
2786       strncat (buf, ", avr:25", size);
2787       break;
2788     case E_AVR_MACH_AVR3:
2789       strncat (buf, ", avr:3", size);
2790       break;
2791     case E_AVR_MACH_AVR31:
2792       strncat (buf, ", avr:31", size);
2793       break;
2794     case E_AVR_MACH_AVR35:
2795       strncat (buf, ", avr:35", size);
2796       break;
2797     case E_AVR_MACH_AVR4:
2798       strncat (buf, ", avr:4", size);
2799       break;
2800     case E_AVR_MACH_AVR5:
2801       strncat (buf, ", avr:5", size);
2802       break;
2803     case E_AVR_MACH_AVR51:
2804       strncat (buf, ", avr:51", size);
2805       break;
2806     case E_AVR_MACH_AVR6:
2807       strncat (buf, ", avr:6", size);
2808       break;
2809     case E_AVR_MACH_AVRTINY:
2810       strncat (buf, ", avr:100", size);
2811       break;
2812     case E_AVR_MACH_XMEGA1:
2813       strncat (buf, ", avr:101", size);
2814       break;
2815     case E_AVR_MACH_XMEGA2:
2816       strncat (buf, ", avr:102", size);
2817       break;
2818     case E_AVR_MACH_XMEGA3:
2819       strncat (buf, ", avr:103", size);
2820       break;
2821     case E_AVR_MACH_XMEGA4:
2822       strncat (buf, ", avr:104", size);
2823       break;
2824     case E_AVR_MACH_XMEGA5:
2825       strncat (buf, ", avr:105", size);
2826       break;
2827     case E_AVR_MACH_XMEGA6:
2828       strncat (buf, ", avr:106", size);
2829       break;
2830     case E_AVR_MACH_XMEGA7:
2831       strncat (buf, ", avr:107", size);
2832       break;
2833     default:
2834       strncat (buf, ", avr:<unknown>", size);
2835       break;
2836     }
2837
2838   size -= strlen (buf);
2839   if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2840     strncat (buf, ", link-relax", size);
2841 }
2842
2843 static void
2844 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2845 {
2846   unsigned abi;
2847   unsigned arch;
2848   unsigned config;
2849   unsigned version;
2850   bfd_boolean has_fpu = FALSE;
2851   unsigned int r = 0;
2852
2853   static const char *ABI_STRINGS[] =
2854   {
2855     "ABI v0", /* use r5 as return register; only used in N1213HC */
2856     "ABI v1", /* use r0 as return register */
2857     "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2858     "ABI v2fp", /* for FPU */
2859     "AABI",
2860     "ABI2 FP+"
2861   };
2862   static const char *VER_STRINGS[] =
2863   {
2864     "Andes ELF V1.3 or older",
2865     "Andes ELF V1.3.1",
2866     "Andes ELF V1.4"
2867   };
2868   static const char *ARCH_STRINGS[] =
2869   {
2870     "",
2871     "Andes Star v1.0",
2872     "Andes Star v2.0",
2873     "Andes Star v3.0",
2874     "Andes Star v3.0m"
2875   };
2876
2877   abi = EF_NDS_ABI & e_flags;
2878   arch = EF_NDS_ARCH & e_flags;
2879   config = EF_NDS_INST & e_flags;
2880   version = EF_NDS32_ELF_VERSION & e_flags;
2881
2882   memset (buf, 0, size);
2883
2884   switch (abi)
2885     {
2886     case E_NDS_ABI_V0:
2887     case E_NDS_ABI_V1:
2888     case E_NDS_ABI_V2:
2889     case E_NDS_ABI_V2FP:
2890     case E_NDS_ABI_AABI:
2891     case E_NDS_ABI_V2FP_PLUS:
2892       /* In case there are holes in the array.  */
2893       r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2894       break;
2895
2896     default:
2897       r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2898       break;
2899     }
2900
2901   switch (version)
2902     {
2903     case E_NDS32_ELF_VER_1_2:
2904     case E_NDS32_ELF_VER_1_3:
2905     case E_NDS32_ELF_VER_1_4:
2906       r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2907       break;
2908
2909     default:
2910       r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2911       break;
2912     }
2913
2914   if (E_NDS_ABI_V0 == abi)
2915     {
2916       /* OLD ABI; only used in N1213HC, has performance extension 1.  */
2917       r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2918       if (arch == E_NDS_ARCH_STAR_V1_0)
2919         r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2920       return;
2921     }
2922
2923   switch (arch)
2924     {
2925     case E_NDS_ARCH_STAR_V1_0:
2926     case E_NDS_ARCH_STAR_V2_0:
2927     case E_NDS_ARCH_STAR_V3_0:
2928     case E_NDS_ARCH_STAR_V3_M:
2929       r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2930       break;
2931
2932     default:
2933       r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2934       /* ARCH version determines how the e_flags are interpreted.
2935          If it is unknown, we cannot proceed.  */
2936       return;
2937     }
2938
2939   /* Newer ABI; Now handle architecture specific flags.  */
2940   if (arch == E_NDS_ARCH_STAR_V1_0)
2941     {
2942       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2943         r += snprintf (buf + r, size -r, ", MFUSR_PC");
2944
2945       if (!(config & E_NDS32_HAS_NO_MAC_INST))
2946         r += snprintf (buf + r, size -r, ", MAC");
2947
2948       if (config & E_NDS32_HAS_DIV_INST)
2949         r += snprintf (buf + r, size -r, ", DIV");
2950
2951       if (config & E_NDS32_HAS_16BIT_INST)
2952         r += snprintf (buf + r, size -r, ", 16b");
2953     }
2954   else
2955     {
2956       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2957         {
2958           if (version <= E_NDS32_ELF_VER_1_3)
2959             r += snprintf (buf + r, size -r, ", [B8]");
2960           else
2961             r += snprintf (buf + r, size -r, ", EX9");
2962         }
2963
2964       if (config & E_NDS32_HAS_MAC_DX_INST)
2965         r += snprintf (buf + r, size -r, ", MAC_DX");
2966
2967       if (config & E_NDS32_HAS_DIV_DX_INST)
2968         r += snprintf (buf + r, size -r, ", DIV_DX");
2969
2970       if (config & E_NDS32_HAS_16BIT_INST)
2971         {
2972           if (version <= E_NDS32_ELF_VER_1_3)
2973             r += snprintf (buf + r, size -r, ", 16b");
2974           else
2975             r += snprintf (buf + r, size -r, ", IFC");
2976         }
2977     }
2978
2979   if (config & E_NDS32_HAS_EXT_INST)
2980     r += snprintf (buf + r, size -r, ", PERF1");
2981
2982   if (config & E_NDS32_HAS_EXT2_INST)
2983     r += snprintf (buf + r, size -r, ", PERF2");
2984
2985   if (config & E_NDS32_HAS_FPU_INST)
2986     {
2987       has_fpu = TRUE;
2988       r += snprintf (buf + r, size -r, ", FPU_SP");
2989     }
2990
2991   if (config & E_NDS32_HAS_FPU_DP_INST)
2992     {
2993       has_fpu = TRUE;
2994       r += snprintf (buf + r, size -r, ", FPU_DP");
2995     }
2996
2997   if (config & E_NDS32_HAS_FPU_MAC_INST)
2998     {
2999       has_fpu = TRUE;
3000       r += snprintf (buf + r, size -r, ", FPU_MAC");
3001     }
3002
3003   if (has_fpu)
3004     {
3005       switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
3006         {
3007         case E_NDS32_FPU_REG_8SP_4DP:
3008           r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
3009           break;
3010         case E_NDS32_FPU_REG_16SP_8DP:
3011           r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
3012           break;
3013         case E_NDS32_FPU_REG_32SP_16DP:
3014           r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
3015           break;
3016         case E_NDS32_FPU_REG_32SP_32DP:
3017           r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
3018           break;
3019         }
3020     }
3021
3022   if (config & E_NDS32_HAS_AUDIO_INST)
3023     r += snprintf (buf + r, size -r, ", AUDIO");
3024
3025   if (config & E_NDS32_HAS_STRING_INST)
3026     r += snprintf (buf + r, size -r, ", STR");
3027
3028   if (config & E_NDS32_HAS_REDUCED_REGS)
3029     r += snprintf (buf + r, size -r, ", 16REG");
3030
3031   if (config & E_NDS32_HAS_VIDEO_INST)
3032     {
3033       if (version <= E_NDS32_ELF_VER_1_3)
3034         r += snprintf (buf + r, size -r, ", VIDEO");
3035       else
3036         r += snprintf (buf + r, size -r, ", SATURATION");
3037     }
3038
3039   if (config & E_NDS32_HAS_ENCRIPT_INST)
3040     r += snprintf (buf + r, size -r, ", ENCRP");
3041
3042   if (config & E_NDS32_HAS_L2C_INST)
3043     r += snprintf (buf + r, size -r, ", L2C");
3044 }
3045
3046 static char *
3047 get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine)
3048 {
3049   static char buf[1024];
3050
3051   buf[0] = '\0';
3052
3053   if (e_flags)
3054     {
3055       switch (e_machine)
3056         {
3057         default:
3058           break;
3059
3060         case EM_ARC_COMPACT2:
3061         case EM_ARC_COMPACT:
3062           decode_ARC_machine_flags (e_flags, e_machine, buf);
3063           break;
3064
3065         case EM_ARM:
3066           decode_ARM_machine_flags (e_flags, buf);
3067           break;
3068
3069         case EM_AVR:
3070           decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3071           break;
3072
3073         case EM_BLACKFIN:
3074           if (e_flags & EF_BFIN_PIC)
3075             strcat (buf, ", PIC");
3076
3077           if (e_flags & EF_BFIN_FDPIC)
3078             strcat (buf, ", FDPIC");
3079
3080           if (e_flags & EF_BFIN_CODE_IN_L1)
3081             strcat (buf, ", code in L1");
3082
3083           if (e_flags & EF_BFIN_DATA_IN_L1)
3084             strcat (buf, ", data in L1");
3085
3086           break;
3087
3088         case EM_CYGNUS_FRV:
3089           switch (e_flags & EF_FRV_CPU_MASK)
3090             {
3091             case EF_FRV_CPU_GENERIC:
3092               break;
3093
3094             default:
3095               strcat (buf, ", fr???");
3096               break;
3097
3098             case EF_FRV_CPU_FR300:
3099               strcat (buf, ", fr300");
3100               break;
3101
3102             case EF_FRV_CPU_FR400:
3103               strcat (buf, ", fr400");
3104               break;
3105             case EF_FRV_CPU_FR405:
3106               strcat (buf, ", fr405");
3107               break;
3108
3109             case EF_FRV_CPU_FR450:
3110               strcat (buf, ", fr450");
3111               break;
3112
3113             case EF_FRV_CPU_FR500:
3114               strcat (buf, ", fr500");
3115               break;
3116             case EF_FRV_CPU_FR550:
3117               strcat (buf, ", fr550");
3118               break;
3119
3120             case EF_FRV_CPU_SIMPLE:
3121               strcat (buf, ", simple");
3122               break;
3123             case EF_FRV_CPU_TOMCAT:
3124               strcat (buf, ", tomcat");
3125               break;
3126             }
3127           break;
3128
3129         case EM_68K:
3130           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3131             strcat (buf, ", m68000");
3132           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3133             strcat (buf, ", cpu32");
3134           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3135             strcat (buf, ", fido_a");
3136           else
3137             {
3138               char const * isa = _("unknown");
3139               char const * mac = _("unknown mac");
3140               char const * additional = NULL;
3141
3142               switch (e_flags & EF_M68K_CF_ISA_MASK)
3143                 {
3144                 case EF_M68K_CF_ISA_A_NODIV:
3145                   isa = "A";
3146                   additional = ", nodiv";
3147                   break;
3148                 case EF_M68K_CF_ISA_A:
3149                   isa = "A";
3150                   break;
3151                 case EF_M68K_CF_ISA_A_PLUS:
3152                   isa = "A+";
3153                   break;
3154                 case EF_M68K_CF_ISA_B_NOUSP:
3155                   isa = "B";
3156                   additional = ", nousp";
3157                   break;
3158                 case EF_M68K_CF_ISA_B:
3159                   isa = "B";
3160                   break;
3161                 case EF_M68K_CF_ISA_C:
3162                   isa = "C";
3163                   break;
3164                 case EF_M68K_CF_ISA_C_NODIV:
3165                   isa = "C";
3166                   additional = ", nodiv";
3167                   break;
3168                 }
3169               strcat (buf, ", cf, isa ");
3170               strcat (buf, isa);
3171               if (additional)
3172                 strcat (buf, additional);
3173               if (e_flags & EF_M68K_CF_FLOAT)
3174                 strcat (buf, ", float");
3175               switch (e_flags & EF_M68K_CF_MAC_MASK)
3176                 {
3177                 case 0:
3178                   mac = NULL;
3179                   break;
3180                 case EF_M68K_CF_MAC:
3181                   mac = "mac";
3182                   break;
3183                 case EF_M68K_CF_EMAC:
3184                   mac = "emac";
3185                   break;
3186                 case EF_M68K_CF_EMAC_B:
3187                   mac = "emac_b";
3188                   break;
3189                 }
3190               if (mac)
3191                 {
3192                   strcat (buf, ", ");
3193                   strcat (buf, mac);
3194                 }
3195             }
3196           break;
3197
3198         case EM_CYGNUS_MEP:
3199           switch (e_flags & EF_MEP_CPU_MASK)
3200             {
3201             case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3202             case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3203             case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3204             case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3205             case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3206             case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3207             default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3208             }
3209
3210           switch (e_flags & EF_MEP_COP_MASK)
3211             {
3212             case EF_MEP_COP_NONE: break;
3213             case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3214             case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3215             case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3216             case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3217             default: strcat (buf, _("<unknown MeP copro type>")); break;
3218             }
3219
3220           if (e_flags & EF_MEP_LIBRARY)
3221             strcat (buf, ", Built for Library");
3222
3223           if (e_flags & EF_MEP_INDEX_MASK)
3224             sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3225                      e_flags & EF_MEP_INDEX_MASK);
3226
3227           if (e_flags & ~ EF_MEP_ALL_FLAGS)
3228             sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3229                      e_flags & ~ EF_MEP_ALL_FLAGS);
3230           break;
3231
3232         case EM_PPC:
3233           if (e_flags & EF_PPC_EMB)
3234             strcat (buf, ", emb");
3235
3236           if (e_flags & EF_PPC_RELOCATABLE)
3237             strcat (buf, _(", relocatable"));
3238
3239           if (e_flags & EF_PPC_RELOCATABLE_LIB)
3240             strcat (buf, _(", relocatable-lib"));
3241           break;
3242
3243         case EM_PPC64:
3244           if (e_flags & EF_PPC64_ABI)
3245             {
3246               char abi[] = ", abiv0";
3247
3248               abi[6] += e_flags & EF_PPC64_ABI;
3249               strcat (buf, abi);
3250             }
3251           break;
3252
3253         case EM_V800:
3254           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3255             strcat (buf, ", RH850 ABI");
3256
3257           if (e_flags & EF_V800_850E3)
3258             strcat (buf, ", V3 architecture");
3259
3260           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3261             strcat (buf, ", FPU not used");
3262
3263           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3264             strcat (buf, ", regmode: COMMON");
3265
3266           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3267             strcat (buf, ", r4 not used");
3268
3269           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3270             strcat (buf, ", r30 not used");
3271
3272           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3273             strcat (buf, ", r5 not used");
3274
3275           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3276             strcat (buf, ", r2 not used");
3277
3278           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3279             {
3280               switch (e_flags & - e_flags)
3281                 {
3282                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3283                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3284                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3285                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3286                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3287                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3288                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3289                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3290                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3291                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3292                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3293                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3294                 default: break;
3295                 }
3296             }
3297           break;
3298
3299         case EM_V850:
3300         case EM_CYGNUS_V850:
3301           switch (e_flags & EF_V850_ARCH)
3302             {
3303             case E_V850E3V5_ARCH:
3304               strcat (buf, ", v850e3v5");
3305               break;
3306             case E_V850E2V3_ARCH:
3307               strcat (buf, ", v850e2v3");
3308               break;
3309             case E_V850E2_ARCH:
3310               strcat (buf, ", v850e2");
3311               break;
3312             case E_V850E1_ARCH:
3313               strcat (buf, ", v850e1");
3314               break;
3315             case E_V850E_ARCH:
3316               strcat (buf, ", v850e");
3317               break;
3318             case E_V850_ARCH:
3319               strcat (buf, ", v850");
3320               break;
3321             default:
3322               strcat (buf, _(", unknown v850 architecture variant"));
3323               break;
3324             }
3325           break;
3326
3327         case EM_M32R:
3328         case EM_CYGNUS_M32R:
3329           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3330             strcat (buf, ", m32r");
3331           break;
3332
3333         case EM_MIPS:
3334         case EM_MIPS_RS3_LE:
3335           if (e_flags & EF_MIPS_NOREORDER)
3336             strcat (buf, ", noreorder");
3337
3338           if (e_flags & EF_MIPS_PIC)
3339             strcat (buf, ", pic");
3340
3341           if (e_flags & EF_MIPS_CPIC)
3342             strcat (buf, ", cpic");
3343
3344           if (e_flags & EF_MIPS_UCODE)
3345             strcat (buf, ", ugen_reserved");
3346
3347           if (e_flags & EF_MIPS_ABI2)
3348             strcat (buf, ", abi2");
3349
3350           if (e_flags & EF_MIPS_OPTIONS_FIRST)
3351             strcat (buf, ", odk first");
3352
3353           if (e_flags & EF_MIPS_32BITMODE)
3354             strcat (buf, ", 32bitmode");
3355
3356           if (e_flags & EF_MIPS_NAN2008)
3357             strcat (buf, ", nan2008");
3358
3359           if (e_flags & EF_MIPS_FP64)
3360             strcat (buf, ", fp64");
3361
3362           switch ((e_flags & EF_MIPS_MACH))
3363             {
3364             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3365             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3366             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3367             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3368             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3369             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3370             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3371             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3372             case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break;
3373             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
3374             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3375             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3376             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3377             case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
3378             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3379             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3380             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3381             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
3382             case E_MIPS_MACH_IAMR2:  strcat (buf, ", interaptiv-mr2"); break;
3383             case 0:
3384             /* We simply ignore the field in this case to avoid confusion:
3385                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3386                extension.  */
3387               break;
3388             default: strcat (buf, _(", unknown CPU")); break;
3389             }
3390
3391           switch ((e_flags & EF_MIPS_ABI))
3392             {
3393             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3394             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3395             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3396             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3397             case 0:
3398             /* We simply ignore the field in this case to avoid confusion:
3399                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3400                This means it is likely to be an o32 file, but not for
3401                sure.  */
3402               break;
3403             default: strcat (buf, _(", unknown ABI")); break;
3404             }
3405
3406           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3407             strcat (buf, ", mdmx");
3408
3409           if (e_flags & EF_MIPS_ARCH_ASE_M16)
3410             strcat (buf, ", mips16");
3411
3412           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3413             strcat (buf, ", micromips");
3414
3415           switch ((e_flags & EF_MIPS_ARCH))
3416             {
3417             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3418             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3419             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3420             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3421             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3422             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3423             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3424             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3425             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3426             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3427             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3428             default: strcat (buf, _(", unknown ISA")); break;
3429             }
3430           break;
3431
3432         case EM_NDS32:
3433           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3434           break;
3435
3436         case EM_RISCV:
3437           if (e_flags & EF_RISCV_RVC)
3438             strcat (buf, ", RVC");
3439
3440           switch (e_flags & EF_RISCV_FLOAT_ABI)
3441             {
3442             case EF_RISCV_FLOAT_ABI_SOFT:
3443               strcat (buf, ", soft-float ABI");
3444               break;
3445
3446             case EF_RISCV_FLOAT_ABI_SINGLE:
3447               strcat (buf, ", single-float ABI");
3448               break;
3449
3450             case EF_RISCV_FLOAT_ABI_DOUBLE:
3451               strcat (buf, ", double-float ABI");
3452               break;
3453
3454             case EF_RISCV_FLOAT_ABI_QUAD:
3455               strcat (buf, ", quad-float ABI");
3456               break;
3457             }
3458           break;
3459
3460         case EM_SH:
3461           switch ((e_flags & EF_SH_MACH_MASK))
3462             {
3463             case EF_SH1: strcat (buf, ", sh1"); break;
3464             case EF_SH2: strcat (buf, ", sh2"); break;
3465             case EF_SH3: strcat (buf, ", sh3"); break;
3466             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3467             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3468             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3469             case EF_SH3E: strcat (buf, ", sh3e"); break;
3470             case EF_SH4: strcat (buf, ", sh4"); break;
3471             case EF_SH5: strcat (buf, ", sh5"); break;
3472             case EF_SH2E: strcat (buf, ", sh2e"); break;
3473             case EF_SH4A: strcat (buf, ", sh4a"); break;
3474             case EF_SH2A: strcat (buf, ", sh2a"); break;
3475             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3476             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3477             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3478             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3479             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3480             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3481             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3482             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3483             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3484             default: strcat (buf, _(", unknown ISA")); break;
3485             }
3486
3487           if (e_flags & EF_SH_PIC)
3488             strcat (buf, ", pic");
3489
3490           if (e_flags & EF_SH_FDPIC)
3491             strcat (buf, ", fdpic");
3492           break;
3493
3494         case EM_OR1K:
3495           if (e_flags & EF_OR1K_NODELAY)
3496             strcat (buf, ", no delay");
3497           break;
3498
3499         case EM_SPARCV9:
3500           if (e_flags & EF_SPARC_32PLUS)
3501             strcat (buf, ", v8+");
3502
3503           if (e_flags & EF_SPARC_SUN_US1)
3504             strcat (buf, ", ultrasparcI");
3505
3506           if (e_flags & EF_SPARC_SUN_US3)
3507             strcat (buf, ", ultrasparcIII");
3508
3509           if (e_flags & EF_SPARC_HAL_R1)
3510             strcat (buf, ", halr1");
3511
3512           if (e_flags & EF_SPARC_LEDATA)
3513             strcat (buf, ", ledata");
3514
3515           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3516             strcat (buf, ", tso");
3517
3518           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3519             strcat (buf, ", pso");
3520
3521           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3522             strcat (buf, ", rmo");
3523           break;
3524
3525         case EM_PARISC:
3526           switch (e_flags & EF_PARISC_ARCH)
3527             {
3528             case EFA_PARISC_1_0:
3529               strcpy (buf, ", PA-RISC 1.0");
3530               break;
3531             case EFA_PARISC_1_1:
3532               strcpy (buf, ", PA-RISC 1.1");
3533               break;
3534             case EFA_PARISC_2_0:
3535               strcpy (buf, ", PA-RISC 2.0");
3536               break;
3537             default:
3538               break;
3539             }
3540           if (e_flags & EF_PARISC_TRAPNIL)
3541             strcat (buf, ", trapnil");
3542           if (e_flags & EF_PARISC_EXT)
3543             strcat (buf, ", ext");
3544           if (e_flags & EF_PARISC_LSB)
3545             strcat (buf, ", lsb");
3546           if (e_flags & EF_PARISC_WIDE)
3547             strcat (buf, ", wide");
3548           if (e_flags & EF_PARISC_NO_KABP)
3549             strcat (buf, ", no kabp");
3550           if (e_flags & EF_PARISC_LAZYSWAP)
3551             strcat (buf, ", lazyswap");
3552           break;
3553
3554         case EM_PJ:
3555         case EM_PJ_OLD:
3556           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3557             strcat (buf, ", new calling convention");
3558
3559           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3560             strcat (buf, ", gnu calling convention");
3561           break;
3562
3563         case EM_IA_64:
3564           if ((e_flags & EF_IA_64_ABI64))
3565             strcat (buf, ", 64-bit");
3566           else
3567             strcat (buf, ", 32-bit");
3568           if ((e_flags & EF_IA_64_REDUCEDFP))
3569             strcat (buf, ", reduced fp model");
3570           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3571             strcat (buf, ", no function descriptors, constant gp");
3572           else if ((e_flags & EF_IA_64_CONS_GP))
3573             strcat (buf, ", constant gp");
3574           if ((e_flags & EF_IA_64_ABSOLUTE))
3575             strcat (buf, ", absolute");
3576           if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3577             {
3578               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3579                 strcat (buf, ", vms_linkages");
3580               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3581                 {
3582                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3583                   break;
3584                 case EF_IA_64_VMS_COMCOD_WARNING:
3585                   strcat (buf, ", warning");
3586                   break;
3587                 case EF_IA_64_VMS_COMCOD_ERROR:
3588                   strcat (buf, ", error");
3589                   break;
3590                 case EF_IA_64_VMS_COMCOD_ABORT:
3591                   strcat (buf, ", abort");
3592                   break;
3593                 default:
3594                   warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3595                         e_flags & EF_IA_64_VMS_COMCOD);
3596                   strcat (buf, ", <unknown>");
3597                 }
3598             }
3599           break;
3600
3601         case EM_VAX:
3602           if ((e_flags & EF_VAX_NONPIC))
3603             strcat (buf, ", non-PIC");
3604           if ((e_flags & EF_VAX_DFLOAT))
3605             strcat (buf, ", D-Float");
3606           if ((e_flags & EF_VAX_GFLOAT))
3607             strcat (buf, ", G-Float");
3608           break;
3609
3610         case EM_VISIUM:
3611           if (e_flags & EF_VISIUM_ARCH_MCM)
3612             strcat (buf, ", mcm");
3613           else if (e_flags & EF_VISIUM_ARCH_MCM24)
3614             strcat (buf, ", mcm24");
3615           if (e_flags & EF_VISIUM_ARCH_GR6)
3616             strcat (buf, ", gr6");
3617           break;
3618
3619         case EM_RL78:
3620           switch (e_flags & E_FLAG_RL78_CPU_MASK)
3621             {
3622             case E_FLAG_RL78_ANY_CPU: break;
3623             case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3624             case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3625             case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3626             }
3627           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3628             strcat (buf, ", 64-bit doubles");
3629           break;
3630
3631         case EM_RX:
3632           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3633             strcat (buf, ", 64-bit doubles");
3634           if (e_flags & E_FLAG_RX_DSP)
3635             strcat (buf, ", dsp");
3636           if (e_flags & E_FLAG_RX_PID)
3637             strcat (buf, ", pid");
3638           if (e_flags & E_FLAG_RX_ABI)
3639             strcat (buf, ", RX ABI");
3640           if (e_flags & E_FLAG_RX_SINSNS_SET)
3641             strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3642                     ? ", uses String instructions" : ", bans String instructions");
3643           if (e_flags & E_FLAG_RX_V2)
3644             strcat (buf, ", V2");
3645           break;
3646
3647         case EM_S390:
3648           if (e_flags & EF_S390_HIGH_GPRS)
3649             strcat (buf, ", highgprs");
3650           break;
3651
3652         case EM_TI_C6000:
3653           if ((e_flags & EF_C6000_REL))
3654             strcat (buf, ", relocatable module");
3655           break;
3656
3657         case EM_MSP430:
3658           strcat (buf, _(": architecture variant: "));
3659           switch (e_flags & EF_MSP430_MACH)
3660             {
3661             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3662             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3663             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3664             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3665             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3666             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3667             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3668             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3669             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3670             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3671             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3672             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3673             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3674             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3675             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3676             default:
3677               strcat (buf, _(": unknown")); break;
3678             }
3679
3680           if (e_flags & ~ EF_MSP430_MACH)
3681             strcat (buf, _(": unknown extra flag bits also present"));
3682         }
3683     }
3684
3685   return buf;
3686 }
3687
3688 static const char *
3689 get_osabi_name (Filedata * filedata, unsigned int osabi)
3690 {
3691   static char buff[32];
3692
3693   switch (osabi)
3694     {
3695     case ELFOSABI_NONE:         return "UNIX - System V";
3696     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3697     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3698     case ELFOSABI_GNU:          return "UNIX - GNU";
3699     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3700     case ELFOSABI_AIX:          return "UNIX - AIX";
3701     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3702     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3703     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3704     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3705     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3706     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3707     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3708     case ELFOSABI_AROS:         return "AROS";
3709     case ELFOSABI_FENIXOS:      return "FenixOS";
3710     case ELFOSABI_CLOUDABI:     return "Nuxi CloudABI";
3711     case ELFOSABI_OPENVOS:      return "Stratus Technologies OpenVOS";
3712     default:
3713       if (osabi >= 64)
3714         switch (filedata->file_header.e_machine)
3715           {
3716           case EM_ARM:
3717             switch (osabi)
3718               {
3719               case ELFOSABI_ARM:        return "ARM";
3720               default:
3721                 break;
3722               }
3723             break;
3724
3725           case EM_MSP430:
3726           case EM_MSP430_OLD:
3727           case EM_VISIUM:
3728             switch (osabi)
3729               {
3730               case ELFOSABI_STANDALONE: return _("Standalone App");
3731               default:
3732                 break;
3733               }
3734             break;
3735
3736           case EM_TI_C6000:
3737             switch (osabi)
3738               {
3739               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3740               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3741               default:
3742                 break;
3743               }
3744             break;
3745
3746           default:
3747             break;
3748           }
3749       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3750       return buff;
3751     }
3752 }
3753
3754 static const char *
3755 get_aarch64_segment_type (unsigned long type)
3756 {
3757   switch (type)
3758     {
3759     case PT_AARCH64_ARCHEXT:  return "AARCH64_ARCHEXT";
3760     default:                  return NULL;
3761     }
3762 }
3763
3764 static const char *
3765 get_arm_segment_type (unsigned long type)
3766 {
3767   switch (type)
3768     {
3769     case PT_ARM_EXIDX: return "EXIDX";
3770     default:           return NULL;
3771     }
3772 }
3773
3774 static const char *
3775 get_s390_segment_type (unsigned long type)
3776 {
3777   switch (type)
3778     {
3779     case PT_S390_PGSTE: return "S390_PGSTE";
3780     default:            return NULL;
3781     }
3782 }
3783
3784 static const char *
3785 get_mips_segment_type (unsigned long type)
3786 {
3787   switch (type)
3788     {
3789     case PT_MIPS_REGINFO:   return "REGINFO";
3790     case PT_MIPS_RTPROC:    return "RTPROC";
3791     case PT_MIPS_OPTIONS:   return "OPTIONS";
3792     case PT_MIPS_ABIFLAGS:  return "ABIFLAGS";
3793     default:                return NULL;
3794     }
3795 }
3796
3797 static const char *
3798 get_parisc_segment_type (unsigned long type)
3799 {
3800   switch (type)
3801     {
3802     case PT_HP_TLS:             return "HP_TLS";
3803     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3804     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3805     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3806     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3807     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3808     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3809     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3810     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3811     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3812     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3813     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3814     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3815     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3816     case PT_HP_STACK:           return "HP_STACK";
3817     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3818     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3819     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3820     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3821     default:                    return NULL;
3822     }
3823 }
3824
3825 static const char *
3826 get_ia64_segment_type (unsigned long type)
3827 {
3828   switch (type)
3829     {
3830     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3831     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3832     case PT_HP_TLS:             return "HP_TLS";
3833     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3834     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3835     case PT_IA_64_HP_STACK:     return "HP_STACK";
3836     default:                    return NULL;
3837     }
3838 }
3839
3840 static const char *
3841 get_tic6x_segment_type (unsigned long type)
3842 {
3843   switch (type)
3844     {
3845     case PT_C6000_PHATTR:  return "C6000_PHATTR";
3846     default:               return NULL;
3847     }
3848 }
3849
3850 static const char *
3851 get_solaris_segment_type (unsigned long type)
3852 {
3853   switch (type)
3854     {
3855     case 0x6464e550: return "PT_SUNW_UNWIND";
3856     case 0x6474e550: return "PT_SUNW_EH_FRAME";
3857     case 0x6ffffff7: return "PT_LOSUNW";
3858     case 0x6ffffffa: return "PT_SUNWBSS";
3859     case 0x6ffffffb: return "PT_SUNWSTACK";
3860     case 0x6ffffffc: return "PT_SUNWDTRACE";
3861     case 0x6ffffffd: return "PT_SUNWCAP";
3862     case 0x6fffffff: return "PT_HISUNW";
3863     default:         return NULL;
3864     }
3865 }
3866
3867 static const char *
3868 get_segment_type (Filedata * filedata, unsigned long p_type)
3869 {
3870   static char buff[32];
3871
3872   switch (p_type)
3873     {
3874     case PT_NULL:       return "NULL";
3875     case PT_LOAD:       return "LOAD";
3876     case PT_DYNAMIC:    return "DYNAMIC";
3877     case PT_INTERP:     return "INTERP";
3878     case PT_NOTE:       return "NOTE";
3879     case PT_SHLIB:      return "SHLIB";
3880     case PT_PHDR:       return "PHDR";
3881     case PT_TLS:        return "TLS";
3882     case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3883     case PT_GNU_STACK:  return "GNU_STACK";
3884     case PT_GNU_RELRO:  return "GNU_RELRO";
3885
3886     default:
3887       if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
3888         {
3889           sprintf (buff, "GNU_MBIND+%#lx",
3890                    p_type - PT_GNU_MBIND_LO);
3891         }
3892       else if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3893         {
3894           const char * result;
3895
3896           switch (filedata->file_header.e_machine)
3897             {
3898             case EM_AARCH64:
3899               result = get_aarch64_segment_type (p_type);
3900               break;
3901             case EM_ARM:
3902               result = get_arm_segment_type (p_type);
3903               break;
3904             case EM_MIPS:
3905             case EM_MIPS_RS3_LE:
3906               result = get_mips_segment_type (p_type);
3907               break;
3908             case EM_PARISC:
3909               result = get_parisc_segment_type (p_type);
3910               break;
3911             case EM_IA_64:
3912               result = get_ia64_segment_type (p_type);
3913               break;
3914             case EM_TI_C6000:
3915               result = get_tic6x_segment_type (p_type);
3916               break;
3917             case EM_S390:
3918             case EM_S390_OLD:
3919               result = get_s390_segment_type (p_type);
3920               break;
3921             default:
3922               result = NULL;
3923               break;
3924             }
3925
3926           if (result != NULL)
3927             return result;
3928
3929           sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
3930         }
3931       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3932         {
3933           const char * result;
3934
3935           switch (filedata->file_header.e_machine)
3936             {
3937             case EM_PARISC:
3938               result = get_parisc_segment_type (p_type);
3939               break;
3940             case EM_IA_64:
3941               result = get_ia64_segment_type (p_type);
3942               break;
3943             default:
3944               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3945                 result = get_solaris_segment_type (p_type);
3946               else
3947                 result = NULL;
3948               break;
3949             }
3950
3951           if (result != NULL)
3952             return result;
3953
3954           sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
3955         }
3956       else
3957         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3958
3959       return buff;
3960     }
3961 }
3962
3963 static const char *
3964 get_arc_section_type_name (unsigned int sh_type)
3965 {
3966   switch (sh_type)
3967     {
3968     case SHT_ARC_ATTRIBUTES:      return "ARC_ATTRIBUTES";
3969     default:
3970       break;
3971     }
3972   return NULL;
3973 }
3974
3975 static const char *
3976 get_mips_section_type_name (unsigned int sh_type)
3977 {
3978   switch (sh_type)
3979     {
3980     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
3981     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
3982     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
3983     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
3984     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
3985     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
3986     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
3987     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
3988     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
3989     case SHT_MIPS_RELD:          return "MIPS_RELD";
3990     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
3991     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
3992     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
3993     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
3994     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
3995     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
3996     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
3997     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
3998     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
3999     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
4000     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
4001     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
4002     case SHT_MIPS_LINE:          return "MIPS_LINE";
4003     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
4004     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
4005     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
4006     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
4007     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
4008     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
4009     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
4010     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
4011     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
4012     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
4013     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
4014     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
4015     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
4016     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
4017     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
4018     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
4019     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
4020     default:
4021       break;
4022     }
4023   return NULL;
4024 }
4025
4026 static const char *
4027 get_parisc_section_type_name (unsigned int sh_type)
4028 {
4029   switch (sh_type)
4030     {
4031     case SHT_PARISC_EXT:        return "PARISC_EXT";
4032     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
4033     case SHT_PARISC_DOC:        return "PARISC_DOC";
4034     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
4035     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
4036     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
4037     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
4038     default:                    return NULL;
4039     }
4040 }
4041
4042 static const char *
4043 get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
4044 {
4045   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
4046   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4047     return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
4048
4049   switch (sh_type)
4050     {
4051     case SHT_IA_64_EXT:                return "IA_64_EXT";
4052     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
4053     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
4054     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
4055     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4056     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
4057     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
4058     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
4059     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
4060     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
4061     default:
4062       break;
4063     }
4064   return NULL;
4065 }
4066
4067 static const char *
4068 get_x86_64_section_type_name (unsigned int sh_type)
4069 {
4070   switch (sh_type)
4071     {
4072     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
4073     default:                    return NULL;
4074     }
4075 }
4076
4077 static const char *
4078 get_aarch64_section_type_name (unsigned int sh_type)
4079 {
4080   switch (sh_type)
4081     {
4082     case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4083     default:                     return NULL;
4084     }
4085 }
4086
4087 static const char *
4088 get_arm_section_type_name (unsigned int sh_type)
4089 {
4090   switch (sh_type)
4091     {
4092     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
4093     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
4094     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
4095     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
4096     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
4097     default:                      return NULL;
4098     }
4099 }
4100
4101 static const char *
4102 get_tic6x_section_type_name (unsigned int sh_type)
4103 {
4104   switch (sh_type)
4105     {
4106     case SHT_C6000_UNWIND:      return "C6000_UNWIND";
4107     case SHT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
4108     case SHT_C6000_ATTRIBUTES:  return "C6000_ATTRIBUTES";
4109     case SHT_TI_ICODE:          return "TI_ICODE";
4110     case SHT_TI_XREF:           return "TI_XREF";
4111     case SHT_TI_HANDLER:        return "TI_HANDLER";
4112     case SHT_TI_INITINFO:       return "TI_INITINFO";
4113     case SHT_TI_PHATTRS:        return "TI_PHATTRS";
4114     default:                    return NULL;
4115     }
4116 }
4117
4118 static const char *
4119 get_msp430x_section_type_name (unsigned int sh_type)
4120 {
4121   switch (sh_type)
4122     {
4123     case SHT_MSP430_SEC_FLAGS:    return "MSP430_SEC_FLAGS";
4124     case SHT_MSP430_SYM_ALIASES:  return "MSP430_SYM_ALIASES";
4125     case SHT_MSP430_ATTRIBUTES:   return "MSP430_ATTRIBUTES";
4126     default:                      return NULL;
4127     }
4128 }
4129
4130 static const char *
4131 get_v850_section_type_name (unsigned int sh_type)
4132 {
4133   switch (sh_type)
4134     {
4135     case SHT_V850_SCOMMON:  return "V850 Small Common";
4136     case SHT_V850_TCOMMON:  return "V850 Tiny Common";
4137     case SHT_V850_ZCOMMON:  return "V850 Zero Common";
4138     case SHT_RENESAS_IOP:   return "RENESAS IOP";
4139     case SHT_RENESAS_INFO:  return "RENESAS INFO";
4140     default:                return NULL;
4141     }
4142 }
4143
4144 static const char *
4145 get_section_type_name (Filedata * filedata, unsigned int sh_type)
4146 {
4147   static char buff[32];
4148   const char * result;
4149
4150   switch (sh_type)
4151     {
4152     case SHT_NULL:              return "NULL";
4153     case SHT_PROGBITS:          return "PROGBITS";
4154     case SHT_SYMTAB:            return "SYMTAB";
4155     case SHT_STRTAB:            return "STRTAB";
4156     case SHT_RELA:              return "RELA";
4157     case SHT_HASH:              return "HASH";
4158     case SHT_DYNAMIC:           return "DYNAMIC";
4159     case SHT_NOTE:              return "NOTE";
4160     case SHT_NOBITS:            return "NOBITS";
4161     case SHT_REL:               return "REL";
4162     case SHT_SHLIB:             return "SHLIB";
4163     case SHT_DYNSYM:            return "DYNSYM";
4164     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
4165     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
4166     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
4167     case SHT_GNU_HASH:          return "GNU_HASH";
4168     case SHT_GROUP:             return "GROUP";
4169     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
4170     case SHT_GNU_verdef:        return "VERDEF";
4171     case SHT_GNU_verneed:       return "VERNEED";
4172     case SHT_GNU_versym:        return "VERSYM";
4173     case 0x6ffffff0:            return "VERSYM";
4174     case 0x6ffffffc:            return "VERDEF";
4175     case 0x7ffffffd:            return "AUXILIARY";
4176     case 0x7fffffff:            return "FILTER";
4177     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
4178
4179     default:
4180       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4181         {
4182           switch (filedata->file_header.e_machine)
4183             {
4184             case EM_ARC:
4185             case EM_ARC_COMPACT:
4186             case EM_ARC_COMPACT2:
4187               result = get_arc_section_type_name (sh_type);
4188               break;
4189             case EM_MIPS:
4190             case EM_MIPS_RS3_LE:
4191               result = get_mips_section_type_name (sh_type);
4192               break;
4193             case EM_PARISC:
4194               result = get_parisc_section_type_name (sh_type);
4195               break;
4196             case EM_IA_64:
4197               result = get_ia64_section_type_name (filedata, sh_type);
4198               break;
4199             case EM_X86_64:
4200             case EM_L1OM:
4201             case EM_K1OM:
4202               result = get_x86_64_section_type_name (sh_type);
4203               break;
4204             case EM_AARCH64:
4205               result = get_aarch64_section_type_name (sh_type);
4206               break;
4207             case EM_ARM:
4208               result = get_arm_section_type_name (sh_type);
4209               break;
4210             case EM_TI_C6000:
4211               result = get_tic6x_section_type_name (sh_type);
4212               break;
4213             case EM_MSP430:
4214               result = get_msp430x_section_type_name (sh_type);
4215               break;
4216             case EM_V800:
4217             case EM_V850:
4218             case EM_CYGNUS_V850:
4219               result = get_v850_section_type_name (sh_type);
4220               break;
4221             default:
4222               result = NULL;
4223               break;
4224             }
4225
4226           if (result != NULL)
4227             return result;
4228
4229           sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4230         }
4231       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4232         {
4233           switch (filedata->file_header.e_machine)
4234             {
4235             case EM_IA_64:
4236               result = get_ia64_section_type_name (filedata, sh_type);
4237               break;
4238             default:
4239               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4240                 result = get_solaris_section_type (sh_type);
4241               else
4242                 {
4243                   switch (sh_type)
4244                     {
4245                     case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4246                     case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4247                     case SHT_GNU_HASH: result = "GNU_HASH"; break;
4248                     case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4249                     default:
4250                       result = NULL;
4251                       break;
4252                     }
4253                 }
4254               break;
4255             }
4256
4257           if (result != NULL)
4258             return result;
4259
4260           sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4261         }
4262       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4263         {
4264           switch (filedata->file_header.e_machine)
4265             {
4266             case EM_V800:
4267             case EM_V850:
4268             case EM_CYGNUS_V850:
4269               result = get_v850_section_type_name (sh_type);
4270               break;
4271             default:
4272               result = NULL;
4273               break;
4274             }
4275
4276           if (result != NULL)
4277             return result;
4278
4279           sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4280         }
4281       else
4282         /* This message is probably going to be displayed in a 15
4283            character wide field, so put the hex value first.  */
4284         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4285
4286       return buff;
4287     }
4288 }
4289
4290 #define OPTION_DEBUG_DUMP       512
4291 #define OPTION_DYN_SYMS         513
4292 #define OPTION_DWARF_DEPTH      514
4293 #define OPTION_DWARF_START      515
4294 #define OPTION_DWARF_CHECK      516
4295
4296 static struct option options[] =
4297 {
4298   {"all",              no_argument, 0, 'a'},
4299   {"file-header",      no_argument, 0, 'h'},
4300   {"program-headers",  no_argument, 0, 'l'},
4301   {"headers",          no_argument, 0, 'e'},
4302   {"histogram",        no_argument, 0, 'I'},
4303   {"segments",         no_argument, 0, 'l'},
4304   {"sections",         no_argument, 0, 'S'},
4305   {"section-headers",  no_argument, 0, 'S'},
4306   {"section-groups",   no_argument, 0, 'g'},
4307   {"section-details",  no_argument, 0, 't'},
4308   {"full-section-name",no_argument, 0, 'N'},
4309   {"symbols",          no_argument, 0, 's'},
4310   {"syms",             no_argument, 0, 's'},
4311   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
4312   {"relocs",           no_argument, 0, 'r'},
4313   {"notes",            no_argument, 0, 'n'},
4314   {"dynamic",          no_argument, 0, 'd'},
4315   {"arch-specific",    no_argument, 0, 'A'},
4316   {"version-info",     no_argument, 0, 'V'},
4317   {"use-dynamic",      no_argument, 0, 'D'},
4318   {"unwind",           no_argument, 0, 'u'},
4319   {"archive-index",    no_argument, 0, 'c'},
4320   {"hex-dump",         required_argument, 0, 'x'},
4321   {"relocated-dump",   required_argument, 0, 'R'},
4322   {"string-dump",      required_argument, 0, 'p'},
4323   {"decompress",       no_argument, 0, 'z'},
4324 #ifdef SUPPORT_DISASSEMBLY
4325   {"instruction-dump", required_argument, 0, 'i'},
4326 #endif
4327   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
4328
4329   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
4330   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
4331   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
4332
4333   {"version",          no_argument, 0, 'v'},
4334   {"wide",             no_argument, 0, 'W'},
4335   {"help",             no_argument, 0, 'H'},
4336   {0,                  no_argument, 0, 0}
4337 };
4338
4339 static void
4340 usage (FILE * stream)
4341 {
4342   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4343   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4344   fprintf (stream, _(" Options are:\n\
4345   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4346   -h --file-header       Display the ELF file header\n\
4347   -l --program-headers   Display the program headers\n\
4348      --segments          An alias for --program-headers\n\
4349   -S --section-headers   Display the sections' header\n\
4350      --sections          An alias for --section-headers\n\
4351   -g --section-groups    Display the section groups\n\
4352   -t --section-details   Display the section details\n\
4353   -e --headers           Equivalent to: -h -l -S\n\
4354   -s --syms              Display the symbol table\n\
4355      --symbols           An alias for --syms\n\
4356   --dyn-syms             Display the dynamic symbol table\n\
4357   -n --notes             Display the core notes (if present)\n\
4358   -r --relocs            Display the relocations (if present)\n\
4359   -u --unwind            Display the unwind info (if present)\n\
4360   -d --dynamic           Display the dynamic section (if present)\n\
4361   -V --version-info      Display the version sections (if present)\n\
4362   -A --arch-specific     Display architecture specific information (if any)\n\
4363   -c --archive-index     Display the symbol/file index in an archive\n\
4364   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
4365   -x --hex-dump=<number|name>\n\
4366                          Dump the contents of section <number|name> as bytes\n\
4367   -p --string-dump=<number|name>\n\
4368                          Dump the contents of section <number|name> as strings\n\
4369   -R --relocated-dump=<number|name>\n\
4370                          Dump the contents of section <number|name> as relocated bytes\n\
4371   -z --decompress        Decompress section before dumping it\n\
4372   -w[lLiaprmfFsoRtUuTgAckK] or\n\
4373   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4374                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4375                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4376                =addr,=cu_index,=links,=follow-links]\n\
4377                          Display the contents of DWARF debug sections\n"));
4378   fprintf (stream, _("\
4379   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
4380   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
4381                          or deeper\n"));
4382 #ifdef SUPPORT_DISASSEMBLY
4383   fprintf (stream, _("\
4384   -i --instruction-dump=<number|name>\n\
4385                          Disassemble the contents of section <number|name>\n"));
4386 #endif
4387   fprintf (stream, _("\
4388   -I --histogram         Display histogram of bucket list lengths\n\
4389   -W --wide              Allow output width to exceed 80 characters\n\
4390   @<file>                Read options from <file>\n\
4391   -H --help              Display this information\n\
4392   -v --version           Display the version number of readelf\n"));
4393
4394   if (REPORT_BUGS_TO[0] && stream == stdout)
4395     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4396
4397   exit (stream == stdout ? 0 : 1);
4398 }
4399
4400 /* Record the fact that the user wants the contents of section number
4401    SECTION to be displayed using the method(s) encoded as flags bits
4402    in TYPE.  Note, TYPE can be zero if we are creating the array for
4403    the first time.  */
4404
4405 static void
4406 request_dump_bynumber (Filedata * filedata, unsigned int section, dump_type type)
4407 {
4408   if (section >= filedata->num_dump_sects)
4409     {
4410       dump_type * new_dump_sects;
4411
4412       new_dump_sects = (dump_type *) calloc (section + 1,
4413                                              sizeof (* new_dump_sects));
4414
4415       if (new_dump_sects == NULL)
4416         error (_("Out of memory allocating dump request table.\n"));
4417       else
4418         {
4419           if (filedata->dump_sects)
4420             {
4421               /* Copy current flag settings.  */
4422               memcpy (new_dump_sects, filedata->dump_sects,
4423                       filedata->num_dump_sects * sizeof (* new_dump_sects));
4424
4425               free (filedata->dump_sects);
4426             }
4427
4428           filedata->dump_sects = new_dump_sects;
4429           filedata->num_dump_sects = section + 1;
4430         }
4431     }
4432
4433   if (filedata->dump_sects)
4434     filedata->dump_sects[section] |= type;
4435 }
4436
4437 /* Request a dump by section name.  */
4438
4439 static void
4440 request_dump_byname (const char * section, dump_type type)
4441 {
4442   struct dump_list_entry * new_request;
4443
4444   new_request = (struct dump_list_entry *)
4445       malloc (sizeof (struct dump_list_entry));
4446   if (!new_request)
4447     error (_("Out of memory allocating dump request table.\n"));
4448
4449   new_request->name = strdup (section);
4450   if (!new_request->name)
4451     error (_("Out of memory allocating dump request table.\n"));
4452
4453   new_request->type = type;
4454
4455   new_request->next = dump_sects_byname;
4456   dump_sects_byname = new_request;
4457 }
4458
4459 static inline void
4460 request_dump (Filedata * filedata, dump_type type)
4461 {
4462   int section;
4463   char * cp;
4464
4465   do_dump++;
4466   section = strtoul (optarg, & cp, 0);
4467
4468   if (! *cp && section >= 0)
4469     request_dump_bynumber (filedata, section, type);
4470   else
4471     request_dump_byname (optarg, type);
4472 }
4473
4474 static void
4475 parse_args (Filedata * filedata, int argc, char ** argv)
4476 {
4477   int c;
4478
4479   if (argc < 2)
4480     usage (stderr);
4481
4482   while ((c = getopt_long
4483           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4484     {
4485       switch (c)
4486         {
4487         case 0:
4488           /* Long options.  */
4489           break;
4490         case 'H':
4491           usage (stdout);
4492           break;
4493
4494         case 'a':
4495           do_syms = TRUE;
4496           do_reloc = TRUE;
4497           do_unwind = TRUE;
4498           do_dynamic = TRUE;
4499           do_header = TRUE;
4500           do_sections = TRUE;
4501           do_section_groups = TRUE;
4502           do_segments = TRUE;
4503           do_version = TRUE;
4504           do_histogram = TRUE;
4505           do_arch = TRUE;
4506           do_notes = TRUE;
4507           break;
4508         case 'g':
4509           do_section_groups = TRUE;
4510           break;
4511         case 't':
4512         case 'N':
4513           do_sections = TRUE;
4514           do_section_details = TRUE;
4515           break;
4516         case 'e':
4517           do_header = TRUE;
4518           do_sections = TRUE;
4519           do_segments = TRUE;
4520           break;
4521         case 'A':
4522           do_arch = TRUE;
4523           break;
4524         case 'D':
4525           do_using_dynamic = TRUE;
4526           break;
4527         case 'r':
4528           do_reloc = TRUE;
4529           break;
4530         case 'u':
4531           do_unwind = TRUE;
4532           break;
4533         case 'h':
4534           do_header = TRUE;
4535           break;
4536         case 'l':
4537           do_segments = TRUE;
4538           break;
4539         case 's':
4540           do_syms = TRUE;
4541           break;
4542         case 'S':
4543           do_sections = TRUE;
4544           break;
4545         case 'd':
4546           do_dynamic = TRUE;
4547           break;
4548         case 'I':
4549           do_histogram = TRUE;
4550           break;
4551         case 'n':
4552           do_notes = TRUE;
4553           break;
4554         case 'c':
4555           do_archive_index = TRUE;
4556           break;
4557         case 'x':
4558           request_dump (filedata, HEX_DUMP);
4559           break;
4560         case 'p':
4561           request_dump (filedata, STRING_DUMP);
4562           break;
4563         case 'R':
4564           request_dump (filedata, RELOC_DUMP);
4565           break;
4566         case 'z':
4567           decompress_dumps = TRUE;
4568           break;
4569         case 'w':
4570           do_dump = TRUE;
4571           if (optarg == 0)
4572             {
4573               do_debugging = TRUE;
4574               dwarf_select_sections_all ();
4575             }
4576           else
4577             {
4578               do_debugging = FALSE;
4579               dwarf_select_sections_by_letters (optarg);
4580             }
4581           break;
4582         case OPTION_DEBUG_DUMP:
4583           do_dump = TRUE;
4584           if (optarg == 0)
4585             do_debugging = TRUE;
4586           else
4587             {
4588               do_debugging = FALSE;
4589               dwarf_select_sections_by_names (optarg);
4590             }
4591           break;
4592         case OPTION_DWARF_DEPTH:
4593           {
4594             char *cp;
4595
4596             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4597           }
4598           break;
4599         case OPTION_DWARF_START:
4600           {
4601             char *cp;
4602
4603             dwarf_start_die = strtoul (optarg, & cp, 0);
4604           }
4605           break;
4606         case OPTION_DWARF_CHECK:
4607           dwarf_check = TRUE;
4608           break;
4609         case OPTION_DYN_SYMS:
4610           do_dyn_syms = TRUE;
4611           break;
4612 #ifdef SUPPORT_DISASSEMBLY
4613         case 'i':
4614           request_dump (filedata, DISASS_DUMP);
4615           break;
4616 #endif
4617         case 'v':
4618           print_version (program_name);
4619           break;
4620         case 'V':
4621           do_version = TRUE;
4622           break;
4623         case 'W':
4624           do_wide = TRUE;
4625           break;
4626         default:
4627           /* xgettext:c-format */
4628           error (_("Invalid option '-%c'\n"), c);
4629           /* Fall through.  */
4630         case '?':
4631           usage (stderr);
4632         }
4633     }
4634
4635   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4636       && !do_segments && !do_header && !do_dump && !do_version
4637       && !do_histogram && !do_debugging && !do_arch && !do_notes
4638       && !do_section_groups && !do_archive_index
4639       && !do_dyn_syms)
4640     usage (stderr);
4641 }
4642
4643 static const char *
4644 get_elf_class (unsigned int elf_class)
4645 {
4646   static char buff[32];
4647
4648   switch (elf_class)
4649     {
4650     case ELFCLASSNONE: return _("none");
4651     case ELFCLASS32:   return "ELF32";
4652     case ELFCLASS64:   return "ELF64";
4653     default:
4654       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4655       return buff;
4656     }
4657 }
4658
4659 static const char *
4660 get_data_encoding (unsigned int encoding)
4661 {
4662   static char buff[32];
4663
4664   switch (encoding)
4665     {
4666     case ELFDATANONE: return _("none");
4667     case ELFDATA2LSB: return _("2's complement, little endian");
4668     case ELFDATA2MSB: return _("2's complement, big endian");
4669     default:
4670       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4671       return buff;
4672     }
4673 }
4674
4675 /* Decode the data held in 'filedata->file_header'.  */
4676
4677 static bfd_boolean
4678 process_file_header (Filedata * filedata)
4679 {
4680   Elf_Internal_Ehdr * header = & filedata->file_header;
4681
4682   if (   header->e_ident[EI_MAG0] != ELFMAG0
4683       || header->e_ident[EI_MAG1] != ELFMAG1
4684       || header->e_ident[EI_MAG2] != ELFMAG2
4685       || header->e_ident[EI_MAG3] != ELFMAG3)
4686     {
4687       error
4688         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4689       return FALSE;
4690     }
4691
4692   init_dwarf_regnames (header->e_machine);
4693
4694   if (do_header)
4695     {
4696       unsigned i;
4697
4698       printf (_("ELF Header:\n"));
4699       printf (_("  Magic:   "));
4700       for (i = 0; i < EI_NIDENT; i++)
4701         printf ("%2.2x ", header->e_ident[i]);
4702       printf ("\n");
4703       printf (_("  Class:                             %s\n"),
4704               get_elf_class (header->e_ident[EI_CLASS]));
4705       printf (_("  Data:                              %s\n"),
4706               get_data_encoding (header->e_ident[EI_DATA]));
4707       printf (_("  Version:                           %d %s\n"),
4708               header->e_ident[EI_VERSION],
4709               (header->e_ident[EI_VERSION] == EV_CURRENT
4710                ? "(current)"
4711                : (header->e_ident[EI_VERSION] != EV_NONE
4712                   ? _("<unknown: %lx>")
4713                   : "")));
4714       printf (_("  OS/ABI:                            %s\n"),
4715               get_osabi_name (filedata, header->e_ident[EI_OSABI]));
4716       printf (_("  ABI Version:                       %d\n"),
4717               header->e_ident[EI_ABIVERSION]);
4718       printf (_("  Type:                              %s\n"),
4719               get_file_type (header->e_type));
4720       printf (_("  Machine:                           %s\n"),
4721               get_machine_name (header->e_machine));
4722       printf (_("  Version:                           0x%lx\n"),
4723               (unsigned long) header->e_version);
4724
4725       printf (_("  Entry point address:               "));
4726       print_vma ((bfd_vma) header->e_entry, PREFIX_HEX);
4727       printf (_("\n  Start of program headers:          "));
4728       print_vma ((bfd_vma) header->e_phoff, DEC);
4729       printf (_(" (bytes into file)\n  Start of section headers:          "));
4730       print_vma ((bfd_vma) header->e_shoff, DEC);
4731       printf (_(" (bytes into file)\n"));
4732
4733       printf (_("  Flags:                             0x%lx%s\n"),
4734               (unsigned long) header->e_flags,
4735               get_machine_flags (filedata, header->e_flags, header->e_machine));
4736       printf (_("  Size of this header:               %ld (bytes)\n"),
4737               (long) header->e_ehsize);
4738       printf (_("  Size of program headers:           %ld (bytes)\n"),
4739               (long) header->e_phentsize);
4740       printf (_("  Number of program headers:         %ld"),
4741               (long) header->e_phnum);
4742       if (filedata->section_headers != NULL
4743           && header->e_phnum == PN_XNUM
4744           && filedata->section_headers[0].sh_info != 0)
4745         printf (" (%ld)", (long) filedata->section_headers[0].sh_info);
4746       putc ('\n', stdout);
4747       printf (_("  Size of section headers:           %ld (bytes)\n"),
4748               (long) header->e_shentsize);
4749       printf (_("  Number of section headers:         %ld"),
4750               (long) header->e_shnum);
4751       if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
4752         printf (" (%ld)", (long) filedata->section_headers[0].sh_size);
4753       putc ('\n', stdout);
4754       printf (_("  Section header string table index: %ld"),
4755               (long) header->e_shstrndx);
4756       if (filedata->section_headers != NULL
4757           && header->e_shstrndx == (SHN_XINDEX & 0xffff))
4758         printf (" (%u)", filedata->section_headers[0].sh_link);
4759       else if (header->e_shstrndx != SHN_UNDEF
4760                && header->e_shstrndx >= header->e_shnum)
4761         printf (_(" <corrupt: out of range>"));
4762       putc ('\n', stdout);
4763     }
4764
4765   if (filedata->section_headers != NULL)
4766     {
4767       if (header->e_phnum == PN_XNUM
4768           && filedata->section_headers[0].sh_info != 0)
4769         header->e_phnum = filedata->section_headers[0].sh_info;
4770       if (header->e_shnum == SHN_UNDEF)
4771         header->e_shnum = filedata->section_headers[0].sh_size;
4772       if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
4773         header->e_shstrndx = filedata->section_headers[0].sh_link;
4774       if (header->e_shstrndx >= header->e_shnum)
4775         header->e_shstrndx = SHN_UNDEF;
4776       free (filedata->section_headers);
4777       filedata->section_headers = NULL;
4778     }
4779
4780   return TRUE;
4781 }
4782
4783 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4784    Returns TRUE upon success, FALSE otherwise.  Loads 32-bit headers.  */
4785
4786 static bfd_boolean
4787 get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4788 {
4789   Elf32_External_Phdr * phdrs;
4790   Elf32_External_Phdr * external;
4791   Elf_Internal_Phdr *   internal;
4792   unsigned int i;
4793   unsigned int size = filedata->file_header.e_phentsize;
4794   unsigned int num  = filedata->file_header.e_phnum;
4795
4796   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4797   if (size == 0 || num == 0)
4798     return FALSE;
4799   if (size < sizeof * phdrs)
4800     {
4801       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4802       return FALSE;
4803     }
4804   if (size > sizeof * phdrs)
4805     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4806
4807   phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4808                                             size, num, _("program headers"));
4809   if (phdrs == NULL)
4810     return FALSE;
4811
4812   for (i = 0, internal = pheaders, external = phdrs;
4813        i < filedata->file_header.e_phnum;
4814        i++, internal++, external++)
4815     {
4816       internal->p_type   = BYTE_GET (external->p_type);
4817       internal->p_offset = BYTE_GET (external->p_offset);
4818       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4819       internal->p_paddr  = BYTE_GET (external->p_paddr);
4820       internal->p_filesz = BYTE_GET (external->p_filesz);
4821       internal->p_memsz  = BYTE_GET (external->p_memsz);
4822       internal->p_flags  = BYTE_GET (external->p_flags);
4823       internal->p_align  = BYTE_GET (external->p_align);
4824     }
4825
4826   free (phdrs);
4827   return TRUE;
4828 }
4829
4830 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4831    Returns TRUE upon success, FALSE otherwise.  Loads 64-bit headers.  */
4832
4833 static bfd_boolean
4834 get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4835 {
4836   Elf64_External_Phdr * phdrs;
4837   Elf64_External_Phdr * external;
4838   Elf_Internal_Phdr *   internal;
4839   unsigned int i;
4840   unsigned int size = filedata->file_header.e_phentsize;
4841   unsigned int num  = filedata->file_header.e_phnum;
4842
4843   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4844   if (size == 0 || num == 0)
4845     return FALSE;
4846   if (size < sizeof * phdrs)
4847     {
4848       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4849       return FALSE;
4850     }
4851   if (size > sizeof * phdrs)
4852     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4853
4854   phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4855                                             size, num, _("program headers"));
4856   if (!phdrs)
4857     return FALSE;
4858
4859   for (i = 0, internal = pheaders, external = phdrs;
4860        i < filedata->file_header.e_phnum;
4861        i++, internal++, external++)
4862     {
4863       internal->p_type   = BYTE_GET (external->p_type);
4864       internal->p_flags  = BYTE_GET (external->p_flags);
4865       internal->p_offset = BYTE_GET (external->p_offset);
4866       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4867       internal->p_paddr  = BYTE_GET (external->p_paddr);
4868       internal->p_filesz = BYTE_GET (external->p_filesz);
4869       internal->p_memsz  = BYTE_GET (external->p_memsz);
4870       internal->p_align  = BYTE_GET (external->p_align);
4871     }
4872
4873   free (phdrs);
4874   return TRUE;
4875 }
4876
4877 /* Returns TRUE if the program headers were read into `program_headers'.  */
4878
4879 static bfd_boolean
4880 get_program_headers (Filedata * filedata)
4881 {
4882   Elf_Internal_Phdr * phdrs;
4883
4884   /* Check cache of prior read.  */
4885   if (filedata->program_headers != NULL)
4886     return TRUE;
4887
4888   /* Be kind to memory checkers by looking for
4889      e_phnum values which we know must be invalid.  */
4890   if (filedata->file_header.e_phnum
4891       * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
4892       >= filedata->file_size)
4893     {
4894       error (_("Too many program headers - %#x - the file is not that big\n"),
4895              filedata->file_header.e_phnum);
4896       return FALSE;
4897     }
4898
4899   phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
4900                                          sizeof (Elf_Internal_Phdr));
4901   if (phdrs == NULL)
4902     {
4903       error (_("Out of memory reading %u program headers\n"),
4904              filedata->file_header.e_phnum);
4905       return FALSE;
4906     }
4907
4908   if (is_32bit_elf
4909       ? get_32bit_program_headers (filedata, phdrs)
4910       : get_64bit_program_headers (filedata, phdrs))
4911     {
4912       filedata->program_headers = phdrs;
4913       return TRUE;
4914     }
4915
4916   free (phdrs);
4917   return FALSE;
4918 }
4919
4920 /* Returns TRUE if the program headers were loaded.  */
4921
4922 static bfd_boolean
4923 process_program_headers (Filedata * filedata)
4924 {
4925   Elf_Internal_Phdr * segment;
4926   unsigned int i;
4927   Elf_Internal_Phdr * previous_load = NULL;
4928
4929   if (filedata->file_header.e_phnum == 0)
4930     {
4931       /* PR binutils/12467.  */
4932       if (filedata->file_header.e_phoff != 0)
4933         {
4934           warn (_("possibly corrupt ELF header - it has a non-zero program"
4935                   " header offset, but no program headers\n"));
4936           return FALSE;
4937         }
4938       else if (do_segments)
4939         printf (_("\nThere are no program headers in this file.\n"));
4940       return TRUE;
4941     }
4942
4943   if (do_segments && !do_header)
4944     {
4945       printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
4946       printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
4947       printf (ngettext ("There is %d program header, starting at offset %s\n",
4948                         "There are %d program headers, starting at offset %s\n",
4949                         filedata->file_header.e_phnum),
4950               filedata->file_header.e_phnum,
4951               bfd_vmatoa ("u", filedata->file_header.e_phoff));
4952     }
4953
4954   if (! get_program_headers (filedata))
4955     return TRUE;
4956
4957   if (do_segments)
4958     {
4959       if (filedata->file_header.e_phnum > 1)
4960         printf (_("\nProgram Headers:\n"));
4961       else
4962         printf (_("\nProgram Headers:\n"));
4963
4964       if (is_32bit_elf)
4965         printf
4966           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
4967       else if (do_wide)
4968         printf
4969           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
4970       else
4971         {
4972           printf
4973             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
4974           printf
4975             (_("                 FileSiz            MemSiz              Flags  Align\n"));
4976         }
4977     }
4978
4979   dynamic_addr = 0;
4980   dynamic_size = 0;
4981
4982   for (i = 0, segment = filedata->program_headers;
4983        i < filedata->file_header.e_phnum;
4984        i++, segment++)
4985     {
4986       if (do_segments)
4987         {
4988           printf ("  %-14.14s ", get_segment_type (filedata, segment->p_type));
4989
4990           if (is_32bit_elf)
4991             {
4992               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4993               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4994               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4995               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4996               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4997               printf ("%c%c%c ",
4998                       (segment->p_flags & PF_R ? 'R' : ' '),
4999                       (segment->p_flags & PF_W ? 'W' : ' '),
5000                       (segment->p_flags & PF_X ? 'E' : ' '));
5001               printf ("%#lx", (unsigned long) segment->p_align);
5002             }
5003           else if (do_wide)
5004             {
5005               if ((unsigned long) segment->p_offset == segment->p_offset)
5006                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5007               else
5008                 {
5009                   print_vma (segment->p_offset, FULL_HEX);
5010                   putchar (' ');
5011                 }
5012
5013               print_vma (segment->p_vaddr, FULL_HEX);
5014               putchar (' ');
5015               print_vma (segment->p_paddr, FULL_HEX);
5016               putchar (' ');
5017
5018               if ((unsigned long) segment->p_filesz == segment->p_filesz)
5019                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
5020               else
5021                 {
5022                   print_vma (segment->p_filesz, FULL_HEX);
5023                   putchar (' ');
5024                 }
5025
5026               if ((unsigned long) segment->p_memsz == segment->p_memsz)
5027                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5028               else
5029                 {
5030                   print_vma (segment->p_memsz, FULL_HEX);
5031                 }
5032
5033               printf (" %c%c%c ",
5034                       (segment->p_flags & PF_R ? 'R' : ' '),
5035                       (segment->p_flags & PF_W ? 'W' : ' '),
5036                       (segment->p_flags & PF_X ? 'E' : ' '));
5037
5038               if ((unsigned long) segment->p_align == segment->p_align)
5039                 printf ("%#lx", (unsigned long) segment->p_align);
5040               else
5041                 {
5042                   print_vma (segment->p_align, PREFIX_HEX);
5043                 }
5044             }
5045           else
5046             {
5047               print_vma (segment->p_offset, FULL_HEX);
5048               putchar (' ');
5049               print_vma (segment->p_vaddr, FULL_HEX);
5050               putchar (' ');
5051               print_vma (segment->p_paddr, FULL_HEX);
5052               printf ("\n                 ");
5053               print_vma (segment->p_filesz, FULL_HEX);
5054               putchar (' ');
5055               print_vma (segment->p_memsz, FULL_HEX);
5056               printf ("  %c%c%c    ",
5057                       (segment->p_flags & PF_R ? 'R' : ' '),
5058                       (segment->p_flags & PF_W ? 'W' : ' '),
5059                       (segment->p_flags & PF_X ? 'E' : ' '));
5060               print_vma (segment->p_align, PREFIX_HEX);
5061             }
5062
5063           putc ('\n', stdout);
5064         }
5065
5066       switch (segment->p_type)
5067         {
5068         case PT_LOAD:
5069 #if 0 /* Do not warn about out of order PT_LOAD segments.  Although officially
5070          required by the ELF standard, several programs, including the Linux
5071          kernel, make use of non-ordered segments.  */
5072           if (previous_load
5073               && previous_load->p_vaddr > segment->p_vaddr)
5074             error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5075 #endif
5076           if (segment->p_memsz < segment->p_filesz)
5077             error (_("the segment's file size is larger than its memory size\n"));
5078           previous_load = segment;
5079           break;
5080
5081         case PT_PHDR:
5082           /* PR 20815 - Verify that the program header is loaded into memory.  */
5083           if (i > 0 && previous_load != NULL)
5084             error (_("the PHDR segment must occur before any LOAD segment\n"));
5085           if (filedata->file_header.e_machine != EM_PARISC)
5086             {
5087               unsigned int j;
5088
5089               for (j = 1; j < filedata->file_header.e_phnum; j++)
5090                 if (filedata->program_headers[j].p_vaddr <= segment->p_vaddr
5091                     && (filedata->program_headers[j].p_vaddr
5092                         + filedata->program_headers[j].p_memsz)
5093                     >= (segment->p_vaddr + segment->p_filesz))
5094                   break;
5095               if (j == filedata->file_header.e_phnum)
5096                 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5097             }
5098           break;
5099
5100         case PT_DYNAMIC:
5101           if (dynamic_addr)
5102             error (_("more than one dynamic segment\n"));
5103
5104           /* By default, assume that the .dynamic section is the first
5105              section in the DYNAMIC segment.  */
5106           dynamic_addr = segment->p_offset;
5107           dynamic_size = segment->p_filesz;
5108
5109           /* Try to locate the .dynamic section. If there is
5110              a section header table, we can easily locate it.  */
5111           if (filedata->section_headers != NULL)
5112             {
5113               Elf_Internal_Shdr * sec;
5114
5115               sec = find_section (filedata, ".dynamic");
5116               if (sec == NULL || sec->sh_size == 0)
5117                 {
5118                   /* A corresponding .dynamic section is expected, but on
5119                      IA-64/OpenVMS it is OK for it to be missing.  */
5120                   if (!is_ia64_vms (filedata))
5121                     error (_("no .dynamic section in the dynamic segment\n"));
5122                   break;
5123                 }
5124
5125               if (sec->sh_type == SHT_NOBITS)
5126                 {
5127                   dynamic_size = 0;
5128                   break;
5129                 }
5130
5131               dynamic_addr = sec->sh_offset;
5132               dynamic_size = sec->sh_size;
5133
5134               if (dynamic_addr < segment->p_offset
5135                   || dynamic_addr > segment->p_offset + segment->p_filesz)
5136                 warn (_("the .dynamic section is not contained"
5137                         " within the dynamic segment\n"));
5138               else if (dynamic_addr > segment->p_offset)
5139                 warn (_("the .dynamic section is not the first section"
5140                         " in the dynamic segment.\n"));
5141             }
5142
5143           /* PR binutils/17512: Avoid corrupt dynamic section info in the
5144              segment.  Check this after matching against the section headers
5145              so we don't warn on debuginfo file (which have NOBITS .dynamic
5146              sections).  */
5147           if (dynamic_addr + dynamic_size >= filedata->file_size)
5148             {
5149               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5150               dynamic_addr = dynamic_size = 0;
5151             }
5152           break;
5153
5154         case PT_INTERP:
5155           if (fseek (filedata->handle, archive_file_offset + (long) segment->p_offset,
5156                      SEEK_SET))
5157             error (_("Unable to find program interpreter name\n"));
5158           else
5159             {
5160               char fmt [32];
5161               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5162
5163               if (ret >= (int) sizeof (fmt) || ret < 0)
5164                 error (_("Internal error: failed to create format string to display program interpreter\n"));
5165
5166               program_interpreter[0] = 0;
5167               if (fscanf (filedata->handle, fmt, program_interpreter) <= 0)
5168                 error (_("Unable to read program interpreter name\n"));
5169
5170               if (do_segments)
5171                 printf (_("      [Requesting program interpreter: %s]\n"),
5172                     program_interpreter);
5173             }
5174           break;
5175         }
5176     }
5177
5178   if (do_segments
5179       && filedata->section_headers != NULL
5180       && filedata->string_table != NULL)
5181     {
5182       printf (_("\n Section to Segment mapping:\n"));
5183       printf (_("  Segment Sections...\n"));
5184
5185       for (i = 0; i < filedata->file_header.e_phnum; i++)
5186         {
5187           unsigned int j;
5188           Elf_Internal_Shdr * section;
5189
5190           segment = filedata->program_headers + i;
5191           section = filedata->section_headers + 1;
5192
5193           printf ("   %2.2d     ", i);
5194
5195           for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
5196             {
5197               if (!ELF_TBSS_SPECIAL (section, segment)
5198                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5199                 printf ("%s ", printable_section_name (filedata, section));
5200             }
5201
5202           putc ('\n',stdout);
5203         }
5204     }
5205
5206   return TRUE;
5207 }
5208
5209
5210 /* Find the file offset corresponding to VMA by using the program headers.  */
5211
5212 static long
5213 offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
5214 {
5215   Elf_Internal_Phdr * seg;
5216
5217   if (! get_program_headers (filedata))
5218     {
5219       warn (_("Cannot interpret virtual addresses without program headers.\n"));
5220       return (long) vma;
5221     }
5222
5223   for (seg = filedata->program_headers;
5224        seg < filedata->program_headers + filedata->file_header.e_phnum;
5225        ++seg)
5226     {
5227       if (seg->p_type != PT_LOAD)
5228         continue;
5229
5230       if (vma >= (seg->p_vaddr & -seg->p_align)
5231           && vma + size <= seg->p_vaddr + seg->p_filesz)
5232         return vma - seg->p_vaddr + seg->p_offset;
5233     }
5234
5235   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5236         (unsigned long) vma);
5237   return (long) vma;
5238 }
5239
5240
5241 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5242    If PROBE is true, this is just a probe and we do not generate any error
5243    messages if the load fails.  */
5244
5245 static bfd_boolean
5246 get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
5247 {
5248   Elf32_External_Shdr * shdrs;
5249   Elf_Internal_Shdr *   internal;
5250   unsigned int          i;
5251   unsigned int          size = filedata->file_header.e_shentsize;
5252   unsigned int          num = probe ? 1 : filedata->file_header.e_shnum;
5253
5254   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5255   if (size == 0 || num == 0)
5256     return FALSE;
5257   if (size < sizeof * shdrs)
5258     {
5259       if (! probe)
5260         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5261       return FALSE;
5262     }
5263   if (!probe && size > sizeof * shdrs)
5264     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5265
5266   shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
5267                                             size, num,
5268                                             probe ? NULL : _("section headers"));
5269   if (shdrs == NULL)
5270     return FALSE;
5271
5272   free (filedata->section_headers);
5273   filedata->section_headers = (Elf_Internal_Shdr *)
5274     cmalloc (num, sizeof (Elf_Internal_Shdr));
5275   if (filedata->section_headers == NULL)
5276     {
5277       if (!probe)
5278         error (_("Out of memory reading %u section headers\n"), num);
5279       return FALSE;
5280     }
5281
5282   for (i = 0, internal = filedata->section_headers;
5283        i < num;
5284        i++, internal++)
5285     {
5286       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5287       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5288       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5289       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5290       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5291       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5292       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5293       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5294       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5295       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5296       if (!probe && internal->sh_link > num)
5297         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5298       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5299         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5300     }
5301
5302   free (shdrs);
5303   return TRUE;
5304 }
5305
5306 /* Like get_32bit_section_headers, except that it fetches 64-bit headers.  */
5307
5308 static bfd_boolean
5309 get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
5310 {
5311   Elf64_External_Shdr *  shdrs;
5312   Elf_Internal_Shdr *    internal;
5313   unsigned int           i;
5314   unsigned int           size = filedata->file_header.e_shentsize;
5315   unsigned int           num = probe ? 1 : filedata->file_header.e_shnum;
5316
5317   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5318   if (size == 0 || num == 0)
5319     return FALSE;
5320
5321   if (size < sizeof * shdrs)
5322     {
5323       if (! probe)
5324         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5325       return FALSE;
5326     }
5327
5328   if (! probe && size > sizeof * shdrs)
5329     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5330
5331   shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
5332                                             filedata->file_header.e_shoff,
5333                                             size, num,
5334                                             probe ? NULL : _("section headers"));
5335   if (shdrs == NULL)
5336     return FALSE;
5337
5338   free (filedata->section_headers);
5339   filedata->section_headers = (Elf_Internal_Shdr *)
5340     cmalloc (num, sizeof (Elf_Internal_Shdr));
5341   if (filedata->section_headers == NULL)
5342     {
5343       if (! probe)
5344         error (_("Out of memory reading %u section headers\n"), num);
5345       return FALSE;
5346     }
5347
5348   for (i = 0, internal = filedata->section_headers;
5349        i < num;
5350        i++, internal++)
5351     {
5352       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5353       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5354       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5355       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5356       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5357       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5358       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5359       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5360       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5361       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5362       if (!probe && internal->sh_link > num)
5363         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5364       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5365         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5366     }
5367
5368   free (shdrs);
5369   return TRUE;
5370 }
5371
5372 static Elf_Internal_Sym *
5373 get_32bit_elf_symbols (Filedata *           filedata,
5374                        Elf_Internal_Shdr *  section,
5375                        unsigned long *      num_syms_return)
5376 {
5377   unsigned long number = 0;
5378   Elf32_External_Sym * esyms = NULL;
5379   Elf_External_Sym_Shndx * shndx = NULL;
5380   Elf_Internal_Sym * isyms = NULL;
5381   Elf_Internal_Sym * psym;
5382   unsigned int j;
5383
5384   if (section->sh_size == 0)
5385     {
5386       if (num_syms_return != NULL)
5387         * num_syms_return = 0;
5388       return NULL;
5389     }
5390
5391   /* Run some sanity checks first.  */
5392   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5393     {
5394       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5395              printable_section_name (filedata, section),
5396              (unsigned long) section->sh_entsize);
5397       goto exit_point;
5398     }
5399
5400   if (section->sh_size > filedata->file_size)
5401     {
5402       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5403              printable_section_name (filedata, section),
5404              (unsigned long) section->sh_size);
5405       goto exit_point;
5406     }
5407
5408   number = section->sh_size / section->sh_entsize;
5409
5410   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5411     {
5412       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5413              (unsigned long) section->sh_size,
5414              printable_section_name (filedata, section),
5415              (unsigned long) section->sh_entsize);
5416       goto exit_point;
5417     }
5418
5419   esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5420                                            section->sh_size, _("symbols"));
5421   if (esyms == NULL)
5422     goto exit_point;
5423
5424   {
5425     elf_section_list * entry;
5426
5427     shndx = NULL;
5428     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5429       if (entry->hdr->sh_link == (unsigned long) (section - filedata->section_headers))
5430         {
5431           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5432                                                        entry->hdr->sh_offset,
5433                                                        1, entry->hdr->sh_size,
5434                                                        _("symbol table section indicies"));
5435           if (shndx == NULL)
5436             goto exit_point;
5437           /* PR17531: file: heap-buffer-overflow */
5438           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5439             {
5440               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5441                      printable_section_name (filedata, entry->hdr),
5442                      (unsigned long) entry->hdr->sh_size,
5443                      (unsigned long) section->sh_size);
5444               goto exit_point;
5445             }
5446         }
5447   }
5448
5449   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5450
5451   if (isyms == NULL)
5452     {
5453       error (_("Out of memory reading %lu symbols\n"),
5454              (unsigned long) number);
5455       goto exit_point;
5456     }
5457
5458   for (j = 0, psym = isyms; j < number; j++, psym++)
5459     {
5460       psym->st_name  = BYTE_GET (esyms[j].st_name);
5461       psym->st_value = BYTE_GET (esyms[j].st_value);
5462       psym->st_size  = BYTE_GET (esyms[j].st_size);
5463       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5464       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5465         psym->st_shndx
5466           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5467       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5468         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5469       psym->st_info  = BYTE_GET (esyms[j].st_info);
5470       psym->st_other = BYTE_GET (esyms[j].st_other);
5471     }
5472
5473  exit_point:
5474   if (shndx != NULL)
5475     free (shndx);
5476   if (esyms != NULL)
5477     free (esyms);
5478
5479   if (num_syms_return != NULL)
5480     * num_syms_return = isyms == NULL ? 0 : number;
5481
5482   return isyms;
5483 }
5484
5485 static Elf_Internal_Sym *
5486 get_64bit_elf_symbols (Filedata *           filedata,
5487                        Elf_Internal_Shdr *  section,
5488                        unsigned long *      num_syms_return)
5489 {
5490   unsigned long number = 0;
5491   Elf64_External_Sym * esyms = NULL;
5492   Elf_External_Sym_Shndx * shndx = NULL;
5493   Elf_Internal_Sym * isyms = NULL;
5494   Elf_Internal_Sym * psym;
5495   unsigned int j;
5496
5497   if (section->sh_size == 0)
5498     {
5499       if (num_syms_return != NULL)
5500         * num_syms_return = 0;
5501       return NULL;
5502     }
5503
5504   /* Run some sanity checks first.  */
5505   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5506     {
5507       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5508              printable_section_name (filedata, section),
5509              (unsigned long) section->sh_entsize);
5510       goto exit_point;
5511     }
5512
5513   if (section->sh_size > filedata->file_size)
5514     {
5515       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5516              printable_section_name (filedata, section),
5517              (unsigned long) section->sh_size);
5518       goto exit_point;
5519     }
5520
5521   number = section->sh_size / section->sh_entsize;
5522
5523   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5524     {
5525       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5526              (unsigned long) section->sh_size,
5527              printable_section_name (filedata, section),
5528              (unsigned long) section->sh_entsize);
5529       goto exit_point;
5530     }
5531
5532   esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5533                                            section->sh_size, _("symbols"));
5534   if (!esyms)
5535     goto exit_point;
5536
5537   {
5538     elf_section_list * entry;
5539
5540     shndx = NULL;
5541     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5542       if (entry->hdr->sh_link == (unsigned long) (section - filedata->section_headers))
5543         {
5544           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5545                                                        entry->hdr->sh_offset,
5546                                                        1, entry->hdr->sh_size,
5547                                                        _("symbol table section indicies"));
5548           if (shndx == NULL)
5549             goto exit_point;
5550           /* PR17531: file: heap-buffer-overflow */
5551           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5552             {
5553               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5554                      printable_section_name (filedata, entry->hdr),
5555                      (unsigned long) entry->hdr->sh_size,
5556                      (unsigned long) section->sh_size);
5557               goto exit_point;
5558             }
5559         }
5560   }
5561
5562   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5563
5564   if (isyms == NULL)
5565     {
5566       error (_("Out of memory reading %lu symbols\n"),
5567              (unsigned long) number);
5568       goto exit_point;
5569     }
5570
5571   for (j = 0, psym = isyms; j < number; j++, psym++)
5572     {
5573       psym->st_name  = BYTE_GET (esyms[j].st_name);
5574       psym->st_info  = BYTE_GET (esyms[j].st_info);
5575       psym->st_other = BYTE_GET (esyms[j].st_other);
5576       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5577
5578       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5579         psym->st_shndx
5580           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5581       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5582         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5583
5584       psym->st_value = BYTE_GET (esyms[j].st_value);
5585       psym->st_size  = BYTE_GET (esyms[j].st_size);
5586     }
5587
5588  exit_point:
5589   if (shndx != NULL)
5590     free (shndx);
5591   if (esyms != NULL)
5592     free (esyms);
5593
5594   if (num_syms_return != NULL)
5595     * num_syms_return = isyms == NULL ? 0 : number;
5596
5597   return isyms;
5598 }
5599
5600 static const char *
5601 get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
5602 {
5603   static char buff[1024];
5604   char * p = buff;
5605   unsigned int field_size = is_32bit_elf ? 8 : 16;
5606   signed int sindex;
5607   unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5608   bfd_vma os_flags = 0;
5609   bfd_vma proc_flags = 0;
5610   bfd_vma unknown_flags = 0;
5611   static const struct
5612     {
5613       const char * str;
5614       unsigned int len;
5615     }
5616   flags [] =
5617     {
5618       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5619       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5620       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5621       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5622       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5623       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5624       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5625       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5626       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5627       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5628       /* IA-64 specific.  */
5629       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5630       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5631       /* IA-64 OpenVMS specific.  */
5632       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5633       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5634       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5635       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5636       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5637       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5638       /* Generic.  */
5639       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5640       /* SPARC specific.  */
5641       /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5642       /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5643       /* ARM specific.  */
5644       /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5645       /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5646       /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5647       /* GNU specific.  */
5648       /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5649       /* VLE specific.  */
5650       /* 25 */ { STRING_COMMA_LEN ("VLE") },
5651     };
5652
5653   if (do_section_details)
5654     {
5655       sprintf (buff, "[%*.*lx]: ",
5656                field_size, field_size, (unsigned long) sh_flags);
5657       p += field_size + 4;
5658     }
5659
5660   while (sh_flags)
5661     {
5662       bfd_vma flag;
5663
5664       flag = sh_flags & - sh_flags;
5665       sh_flags &= ~ flag;
5666
5667       if (do_section_details)
5668         {
5669           switch (flag)
5670             {
5671             case SHF_WRITE:             sindex = 0; break;
5672             case SHF_ALLOC:             sindex = 1; break;
5673             case SHF_EXECINSTR:         sindex = 2; break;
5674             case SHF_MERGE:             sindex = 3; break;
5675             case SHF_STRINGS:           sindex = 4; break;
5676             case SHF_INFO_LINK:         sindex = 5; break;
5677             case SHF_LINK_ORDER:        sindex = 6; break;
5678             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5679             case SHF_GROUP:             sindex = 8; break;
5680             case SHF_TLS:               sindex = 9; break;
5681             case SHF_EXCLUDE:           sindex = 18; break;
5682             case SHF_COMPRESSED:        sindex = 20; break;
5683             case SHF_GNU_MBIND:         sindex = 24; break;
5684
5685             default:
5686               sindex = -1;
5687               switch (filedata->file_header.e_machine)
5688                 {
5689                 case EM_IA_64:
5690                   if (flag == SHF_IA_64_SHORT)
5691                     sindex = 10;
5692                   else if (flag == SHF_IA_64_NORECOV)
5693                     sindex = 11;
5694 #ifdef BFD64
5695                   else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5696                     switch (flag)
5697                       {
5698                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5699                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5700                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5701                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5702                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5703                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5704                       default:                        break;
5705                       }
5706 #endif
5707                   break;
5708
5709                 case EM_386:
5710                 case EM_IAMCU:
5711                 case EM_X86_64:
5712                 case EM_L1OM:
5713                 case EM_K1OM:
5714                 case EM_OLD_SPARCV9:
5715                 case EM_SPARC32PLUS:
5716                 case EM_SPARCV9:
5717                 case EM_SPARC:
5718                   if (flag == SHF_ORDERED)
5719                     sindex = 19;
5720                   break;
5721
5722                 case EM_ARM:
5723                   switch (flag)
5724                     {
5725                     case SHF_ENTRYSECT: sindex = 21; break;
5726                     case SHF_ARM_PURECODE: sindex = 22; break;
5727                     case SHF_COMDEF: sindex = 23; break;
5728                     default: break;
5729                     }
5730                   break;
5731                 case EM_PPC:
5732                   if (flag == SHF_PPC_VLE)
5733                     sindex = 25;
5734                   break;
5735
5736                 default:
5737                   break;
5738                 }
5739             }
5740
5741           if (sindex != -1)
5742             {
5743               if (p != buff + field_size + 4)
5744                 {
5745                   if (size < (10 + 2))
5746                     {
5747                       warn (_("Internal error: not enough buffer room for section flag info"));
5748                       return _("<unknown>");
5749                     }
5750                   size -= 2;
5751                   *p++ = ',';
5752                   *p++ = ' ';
5753                 }
5754
5755               size -= flags [sindex].len;
5756               p = stpcpy (p, flags [sindex].str);
5757             }
5758           else if (flag & SHF_MASKOS)
5759             os_flags |= flag;
5760           else if (flag & SHF_MASKPROC)
5761             proc_flags |= flag;
5762           else
5763             unknown_flags |= flag;
5764         }
5765       else
5766         {
5767           switch (flag)
5768             {
5769             case SHF_WRITE:             *p = 'W'; break;
5770             case SHF_ALLOC:             *p = 'A'; break;
5771             case SHF_EXECINSTR:         *p = 'X'; break;
5772             case SHF_MERGE:             *p = 'M'; break;
5773             case SHF_STRINGS:           *p = 'S'; break;
5774             case SHF_INFO_LINK:         *p = 'I'; break;
5775             case SHF_LINK_ORDER:        *p = 'L'; break;
5776             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5777             case SHF_GROUP:             *p = 'G'; break;
5778             case SHF_TLS:               *p = 'T'; break;
5779             case SHF_EXCLUDE:           *p = 'E'; break;
5780             case SHF_COMPRESSED:        *p = 'C'; break;
5781             case SHF_GNU_MBIND:         *p = 'D'; break;
5782
5783             default:
5784               if ((filedata->file_header.e_machine == EM_X86_64
5785                    || filedata->file_header.e_machine == EM_L1OM
5786                    || filedata->file_header.e_machine == EM_K1OM)
5787                   && flag == SHF_X86_64_LARGE)
5788                 *p = 'l';
5789               else if (filedata->file_header.e_machine == EM_ARM
5790                        && flag == SHF_ARM_PURECODE)
5791                   *p = 'y';
5792               else if (filedata->file_header.e_machine == EM_PPC
5793                        && flag == SHF_PPC_VLE)
5794                   *p = 'v';
5795               else if (flag & SHF_MASKOS)
5796                 {
5797                   *p = 'o';
5798                   sh_flags &= ~ SHF_MASKOS;
5799                 }
5800               else if (flag & SHF_MASKPROC)
5801                 {
5802                   *p = 'p';
5803                   sh_flags &= ~ SHF_MASKPROC;
5804                 }
5805               else
5806                 *p = 'x';
5807               break;
5808             }
5809           p++;
5810         }
5811     }
5812
5813   if (do_section_details)
5814     {
5815       if (os_flags)
5816         {
5817           size -= 5 + field_size;
5818           if (p != buff + field_size + 4)
5819             {
5820               if (size < (2 + 1))
5821                 {
5822                   warn (_("Internal error: not enough buffer room for section flag info"));
5823                   return _("<unknown>");
5824                 }
5825               size -= 2;
5826               *p++ = ',';
5827               *p++ = ' ';
5828             }
5829           sprintf (p, "OS (%*.*lx)", field_size, field_size,
5830                    (unsigned long) os_flags);
5831           p += 5 + field_size;
5832         }
5833       if (proc_flags)
5834         {
5835           size -= 7 + field_size;
5836           if (p != buff + field_size + 4)
5837             {
5838               if (size < (2 + 1))
5839                 {
5840                   warn (_("Internal error: not enough buffer room for section flag info"));
5841                   return _("<unknown>");
5842                 }
5843               size -= 2;
5844               *p++ = ',';
5845               *p++ = ' ';
5846             }
5847           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5848                    (unsigned long) proc_flags);
5849           p += 7 + field_size;
5850         }
5851       if (unknown_flags)
5852         {
5853           size -= 10 + field_size;
5854           if (p != buff + field_size + 4)
5855             {
5856               if (size < (2 + 1))
5857                 {
5858                   warn (_("Internal error: not enough buffer room for section flag info"));
5859                   return _("<unknown>");
5860                 }
5861               size -= 2;
5862               *p++ = ',';
5863               *p++ = ' ';
5864             }
5865           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5866                    (unsigned long) unknown_flags);
5867           p += 10 + field_size;
5868         }
5869     }
5870
5871   *p = '\0';
5872   return buff;
5873 }
5874
5875 static unsigned int
5876 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
5877 {
5878   if (is_32bit_elf)
5879     {
5880       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5881
5882       if (size < sizeof (* echdr))
5883         {
5884           error (_("Compressed section is too small even for a compression header\n"));
5885           return 0;
5886         }
5887
5888       chdr->ch_type = BYTE_GET (echdr->ch_type);
5889       chdr->ch_size = BYTE_GET (echdr->ch_size);
5890       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5891       return sizeof (*echdr);
5892     }
5893   else
5894     {
5895       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5896
5897       if (size < sizeof (* echdr))
5898         {
5899           error (_("Compressed section is too small even for a compression header\n"));
5900           return 0;
5901         }
5902
5903       chdr->ch_type = BYTE_GET (echdr->ch_type);
5904       chdr->ch_size = BYTE_GET (echdr->ch_size);
5905       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5906       return sizeof (*echdr);
5907     }
5908 }
5909
5910 static bfd_boolean
5911 process_section_headers (Filedata * filedata)
5912 {
5913   Elf_Internal_Shdr * section;
5914   unsigned int i;
5915
5916   filedata->section_headers = NULL;
5917
5918   if (filedata->file_header.e_shnum == 0)
5919     {
5920       /* PR binutils/12467.  */
5921       if (filedata->file_header.e_shoff != 0)
5922         {
5923           warn (_("possibly corrupt ELF file header - it has a non-zero"
5924                   " section header offset, but no section headers\n"));
5925           return FALSE;
5926         }
5927       else if (do_sections)
5928         printf (_("\nThere are no sections in this file.\n"));
5929
5930       return TRUE;
5931     }
5932
5933   if (do_sections && !do_header)
5934     printf (ngettext ("There is %d section header, "
5935                       "starting at offset 0x%lx:\n",
5936                       "There are %d section headers, "
5937                       "starting at offset 0x%lx:\n",
5938                       filedata->file_header.e_shnum),
5939             filedata->file_header.e_shnum,
5940             (unsigned long) filedata->file_header.e_shoff);
5941
5942   if (is_32bit_elf)
5943     {
5944       if (! get_32bit_section_headers (filedata, FALSE))
5945         return FALSE;
5946     }
5947   else
5948     {
5949       if (! get_64bit_section_headers (filedata, FALSE))
5950         return FALSE;
5951     }
5952
5953   /* Read in the string table, so that we have names to display.  */
5954   if (filedata->file_header.e_shstrndx != SHN_UNDEF
5955        && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
5956     {
5957       section = filedata->section_headers + filedata->file_header.e_shstrndx;
5958
5959       if (section->sh_size != 0)
5960         {
5961           filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
5962                                                       1, section->sh_size,
5963                                                       _("string table"));
5964
5965           filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
5966         }
5967     }
5968
5969   /* Scan the sections for the dynamic symbol table
5970      and dynamic string table and debug sections.  */
5971   dynamic_symbols = NULL;
5972   dynamic_strings = NULL;
5973   dynamic_syminfo = NULL;
5974   symtab_shndx_list = NULL;
5975
5976   eh_addr_size = is_32bit_elf ? 4 : 8;
5977   switch (filedata->file_header.e_machine)
5978     {
5979     case EM_MIPS:
5980     case EM_MIPS_RS3_LE:
5981       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5982          FDE addresses.  However, the ABI also has a semi-official ILP32
5983          variant for which the normal FDE address size rules apply.
5984
5985          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5986          section, where XX is the size of longs in bits.  Unfortunately,
5987          earlier compilers provided no way of distinguishing ILP32 objects
5988          from LP64 objects, so if there's any doubt, we should assume that
5989          the official LP64 form is being used.  */
5990       if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5991           && find_section (filedata, ".gcc_compiled_long32") == NULL)
5992         eh_addr_size = 8;
5993       break;
5994
5995     case EM_H8_300:
5996     case EM_H8_300H:
5997       switch (filedata->file_header.e_flags & EF_H8_MACH)
5998         {
5999         case E_H8_MACH_H8300:
6000         case E_H8_MACH_H8300HN:
6001         case E_H8_MACH_H8300SN:
6002         case E_H8_MACH_H8300SXN:
6003           eh_addr_size = 2;
6004           break;
6005         case E_H8_MACH_H8300H:
6006         case E_H8_MACH_H8300S:
6007         case E_H8_MACH_H8300SX:
6008           eh_addr_size = 4;
6009           break;
6010         }
6011       break;
6012
6013     case EM_M32C_OLD:
6014     case EM_M32C:
6015       switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
6016         {
6017         case EF_M32C_CPU_M16C:
6018           eh_addr_size = 2;
6019           break;
6020         }
6021       break;
6022     }
6023
6024 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
6025   do                                                                    \
6026     {                                                                   \
6027       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
6028       if (section->sh_entsize != expected_entsize)                      \
6029         {                                                               \
6030           char buf[40];                                                 \
6031           sprintf_vma (buf, section->sh_entsize);                       \
6032           /* Note: coded this way so that there is a single string for  \
6033              translation.  */ \
6034           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6035           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6036                    (unsigned) expected_entsize);                        \
6037           section->sh_entsize = expected_entsize;                       \
6038         }                                                               \
6039     }                                                                   \
6040   while (0)
6041
6042 #define CHECK_ENTSIZE(section, i, type)                                 \
6043   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
6044                         sizeof (Elf64_External_##type))
6045
6046   for (i = 0, section = filedata->section_headers;
6047        i < filedata->file_header.e_shnum;
6048        i++, section++)
6049     {
6050       char * name = SECTION_NAME (section);
6051
6052       if (section->sh_type == SHT_DYNSYM)
6053         {
6054           if (dynamic_symbols != NULL)
6055             {
6056               error (_("File contains multiple dynamic symbol tables\n"));
6057               continue;
6058             }
6059
6060           CHECK_ENTSIZE (section, i, Sym);
6061           dynamic_symbols = GET_ELF_SYMBOLS (filedata, section, & num_dynamic_syms);
6062         }
6063       else if (section->sh_type == SHT_STRTAB
6064                && streq (name, ".dynstr"))
6065         {
6066           if (dynamic_strings != NULL)
6067             {
6068               error (_("File contains multiple dynamic string tables\n"));
6069               continue;
6070             }
6071
6072           dynamic_strings = (char *) get_data (NULL, filedata, section->sh_offset,
6073                                                1, section->sh_size,
6074                                                _("dynamic strings"));
6075           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6076         }
6077       else if (section->sh_type == SHT_SYMTAB_SHNDX)
6078         {
6079           elf_section_list * entry = xmalloc (sizeof * entry);
6080
6081           entry->hdr = section;
6082           entry->next = symtab_shndx_list;
6083           symtab_shndx_list = entry;
6084         }
6085       else if (section->sh_type == SHT_SYMTAB)
6086         CHECK_ENTSIZE (section, i, Sym);
6087       else if (section->sh_type == SHT_GROUP)
6088         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6089       else if (section->sh_type == SHT_REL)
6090         CHECK_ENTSIZE (section, i, Rel);
6091       else if (section->sh_type == SHT_RELA)
6092         CHECK_ENTSIZE (section, i, Rela);
6093       else if ((do_debugging || do_debug_info || do_debug_abbrevs
6094                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6095                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6096                 || do_debug_str || do_debug_loc || do_debug_ranges
6097                 || do_debug_addr || do_debug_cu_index || do_debug_links)
6098                && (const_strneq (name, ".debug_")
6099                    || const_strneq (name, ".zdebug_")))
6100         {
6101           if (name[1] == 'z')
6102             name += sizeof (".zdebug_") - 1;
6103           else
6104             name += sizeof (".debug_") - 1;
6105
6106           if (do_debugging
6107               || (do_debug_info     && const_strneq (name, "info"))
6108               || (do_debug_info     && const_strneq (name, "types"))
6109               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
6110               || (do_debug_lines    && strcmp (name, "line") == 0)
6111               || (do_debug_lines    && const_strneq (name, "line."))
6112               || (do_debug_pubnames && const_strneq (name, "pubnames"))
6113               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6114               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6115               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6116               || (do_debug_aranges  && const_strneq (name, "aranges"))
6117               || (do_debug_ranges   && const_strneq (name, "ranges"))
6118               || (do_debug_ranges   && const_strneq (name, "rnglists"))
6119               || (do_debug_frames   && const_strneq (name, "frame"))
6120               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
6121               || (do_debug_macinfo  && const_strneq (name, "macro"))
6122               || (do_debug_str      && const_strneq (name, "str"))
6123               || (do_debug_loc      && const_strneq (name, "loc"))
6124               || (do_debug_loc      && const_strneq (name, "loclists"))
6125               || (do_debug_addr     && const_strneq (name, "addr"))
6126               || (do_debug_cu_index && const_strneq (name, "cu_index"))
6127               || (do_debug_cu_index && const_strneq (name, "tu_index"))
6128               )
6129             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6130         }
6131       /* Linkonce section to be combined with .debug_info at link time.  */
6132       else if ((do_debugging || do_debug_info)
6133                && const_strneq (name, ".gnu.linkonce.wi."))
6134         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6135       else if (do_debug_frames && streq (name, ".eh_frame"))
6136         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6137       else if (do_gdb_index && (streq (name, ".gdb_index")
6138                                 || streq (name, ".debug_names")))
6139         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6140       /* Trace sections for Itanium VMS.  */
6141       else if ((do_debugging || do_trace_info || do_trace_abbrevs
6142                 || do_trace_aranges)
6143                && const_strneq (name, ".trace_"))
6144         {
6145           name += sizeof (".trace_") - 1;
6146
6147           if (do_debugging
6148               || (do_trace_info     && streq (name, "info"))
6149               || (do_trace_abbrevs  && streq (name, "abbrev"))
6150               || (do_trace_aranges  && streq (name, "aranges"))
6151               )
6152             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6153         }
6154       else if ((do_debugging || do_debug_links)
6155                && (const_strneq (name, ".gnu_debuglink")
6156                    || const_strneq (name, ".gnu_debugaltlink")))
6157         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6158     }
6159
6160   if (! do_sections)
6161     return TRUE;
6162
6163   if (filedata->file_header.e_shnum > 1)
6164     printf (_("\nSection Headers:\n"));
6165   else
6166     printf (_("\nSection Header:\n"));
6167
6168   if (is_32bit_elf)
6169     {
6170       if (do_section_details)
6171         {
6172           printf (_("  [Nr] Name\n"));
6173           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
6174         }
6175       else
6176         printf
6177           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
6178     }
6179   else if (do_wide)
6180     {
6181       if (do_section_details)
6182         {
6183           printf (_("  [Nr] Name\n"));
6184           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
6185         }
6186       else
6187         printf
6188           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
6189     }
6190   else
6191     {
6192       if (do_section_details)
6193         {
6194           printf (_("  [Nr] Name\n"));
6195           printf (_("       Type              Address          Offset            Link\n"));
6196           printf (_("       Size              EntSize          Info              Align\n"));
6197         }
6198       else
6199         {
6200           printf (_("  [Nr] Name              Type             Address           Offset\n"));
6201           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
6202         }
6203     }
6204
6205   if (do_section_details)
6206     printf (_("       Flags\n"));
6207
6208   for (i = 0, section = filedata->section_headers;
6209        i < filedata->file_header.e_shnum;
6210        i++, section++)
6211     {
6212       /* Run some sanity checks on the section header.  */
6213
6214       /* Check the sh_link field.  */
6215       switch (section->sh_type)
6216         {
6217         case SHT_SYMTAB_SHNDX:
6218         case SHT_GROUP:
6219         case SHT_HASH:
6220         case SHT_GNU_HASH:
6221         case SHT_GNU_versym:
6222         case SHT_REL:
6223         case SHT_RELA:
6224           if (section->sh_link < 1
6225               || section->sh_link >= filedata->file_header.e_shnum
6226               || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6227                   && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6228             warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6229                   i, section->sh_link);
6230           break;
6231
6232         case SHT_DYNAMIC:
6233         case SHT_SYMTAB:
6234         case SHT_DYNSYM:
6235         case SHT_GNU_verneed:
6236         case SHT_GNU_verdef:
6237         case SHT_GNU_LIBLIST:
6238           if (section->sh_link < 1
6239               || section->sh_link >= filedata->file_header.e_shnum
6240               || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6241             warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6242                   i, section->sh_link);
6243           break;
6244
6245         case SHT_INIT_ARRAY:
6246         case SHT_FINI_ARRAY:
6247         case SHT_PREINIT_ARRAY:
6248           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6249             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6250                   i, section->sh_link);
6251           break;
6252
6253         default:
6254           /* FIXME: Add support for target specific section types.  */
6255 #if 0     /* Currently we do not check other section types as there are too
6256              many special cases.  Stab sections for example have a type
6257              of SHT_PROGBITS but an sh_link field that links to the .stabstr
6258              section.  */
6259           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6260             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6261                   i, section->sh_link);
6262 #endif
6263           break;
6264         }
6265
6266       /* Check the sh_info field.  */
6267       switch (section->sh_type)
6268         {
6269         case SHT_REL:
6270         case SHT_RELA:
6271           if (section->sh_info < 1
6272               || section->sh_info >= filedata->file_header.e_shnum
6273               || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6274                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6275                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6276                   && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6277                   /* FIXME: Are other section types valid ?  */
6278                   && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6279             {
6280               if (section->sh_info == 0
6281                   && (filedata->file_header.e_type == ET_EXEC
6282                       || filedata->file_header.e_type == ET_DYN
6283                       /* These next two tests may be redundant, but
6284                          they have been left in for paranoia's sake.  */
6285                       || streq (SECTION_NAME (section), ".rel.dyn")
6286                       || streq (SECTION_NAME (section), ".rela.dyn")))
6287                 /* Dynamic relocations apply to segments, not sections, so
6288                    they do not need an sh_info value.  */
6289                 ;
6290               else
6291                 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6292                       i, section->sh_info);
6293             }
6294           break;
6295
6296         case SHT_DYNAMIC:
6297         case SHT_HASH:
6298         case SHT_SYMTAB_SHNDX:
6299         case SHT_INIT_ARRAY:
6300         case SHT_FINI_ARRAY:
6301         case SHT_PREINIT_ARRAY:
6302           if (section->sh_info != 0)
6303             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6304                   i, section->sh_info);
6305           break;
6306
6307         case SHT_GROUP:
6308         case SHT_SYMTAB:
6309         case SHT_DYNSYM:
6310           /* A symbol index - we assume that it is valid.  */
6311           break;
6312
6313         default:
6314           /* FIXME: Add support for target specific section types.  */
6315           if (section->sh_type == SHT_NOBITS)
6316             /* NOBITS section headers with non-zero sh_info fields can be
6317                created when a binary is stripped of everything but its debug
6318                information.  The stripped sections have their headers
6319                preserved but their types set to SHT_NOBITS.  So do not check
6320                this type of section.  */
6321             ;
6322           else if (section->sh_flags & SHF_INFO_LINK)
6323             {
6324               if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6325                 warn (_("[%2u]: Expected link to another section in info field"), i);
6326             }
6327           else if (section->sh_type < SHT_LOOS
6328                    && (section->sh_flags & SHF_GNU_MBIND) == 0
6329                    && section->sh_info != 0)
6330             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6331                   i, section->sh_info);
6332           break;
6333         }
6334
6335       /* Check the sh_size field.  */
6336       if (section->sh_size > filedata->file_size
6337           && section->sh_type != SHT_NOBITS
6338           && section->sh_type != SHT_NULL
6339           && section->sh_type < SHT_LOOS)
6340         warn (_("Size of section %u is larger than the entire file!\n"), i);
6341
6342       printf ("  [%2u] ", i);
6343       if (do_section_details)
6344         printf ("%s\n      ", printable_section_name (filedata, section));
6345       else
6346         print_symbol (-17, SECTION_NAME (section));
6347
6348       printf (do_wide ? " %-15s " : " %-15.15s ",
6349               get_section_type_name (filedata, section->sh_type));
6350
6351       if (is_32bit_elf)
6352         {
6353           const char * link_too_big = NULL;
6354
6355           print_vma (section->sh_addr, LONG_HEX);
6356
6357           printf ( " %6.6lx %6.6lx %2.2lx",
6358                    (unsigned long) section->sh_offset,
6359                    (unsigned long) section->sh_size,
6360                    (unsigned long) section->sh_entsize);
6361
6362           if (do_section_details)
6363             fputs ("  ", stdout);
6364           else
6365             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6366
6367           if (section->sh_link >= filedata->file_header.e_shnum)
6368             {
6369               link_too_big = "";
6370               /* The sh_link value is out of range.  Normally this indicates
6371                  an error but it can have special values in Solaris binaries.  */
6372               switch (filedata->file_header.e_machine)
6373                 {
6374                 case EM_386:
6375                 case EM_IAMCU:
6376                 case EM_X86_64:
6377                 case EM_L1OM:
6378                 case EM_K1OM:
6379                 case EM_OLD_SPARCV9:
6380                 case EM_SPARC32PLUS:
6381                 case EM_SPARCV9:
6382                 case EM_SPARC:
6383                   if (section->sh_link == (SHN_BEFORE & 0xffff))
6384                     link_too_big = "BEFORE";
6385                   else if (section->sh_link == (SHN_AFTER & 0xffff))
6386                     link_too_big = "AFTER";
6387                   break;
6388                 default:
6389                   break;
6390                 }
6391             }
6392
6393           if (do_section_details)
6394             {
6395               if (link_too_big != NULL && * link_too_big)
6396                 printf ("<%s> ", link_too_big);
6397               else
6398                 printf ("%2u ", section->sh_link);
6399               printf ("%3u %2lu\n", section->sh_info,
6400                       (unsigned long) section->sh_addralign);
6401             }
6402           else
6403             printf ("%2u %3u %2lu\n",
6404                     section->sh_link,
6405                     section->sh_info,
6406                     (unsigned long) section->sh_addralign);
6407
6408           if (link_too_big && ! * link_too_big)
6409             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6410                   i, section->sh_link);
6411         }
6412       else if (do_wide)
6413         {
6414           print_vma (section->sh_addr, LONG_HEX);
6415
6416           if ((long) section->sh_offset == section->sh_offset)
6417             printf (" %6.6lx", (unsigned long) section->sh_offset);
6418           else
6419             {
6420               putchar (' ');
6421               print_vma (section->sh_offset, LONG_HEX);
6422             }
6423
6424           if ((unsigned long) section->sh_size == section->sh_size)
6425             printf (" %6.6lx", (unsigned long) section->sh_size);
6426           else
6427             {
6428               putchar (' ');
6429               print_vma (section->sh_size, LONG_HEX);
6430             }
6431
6432           if ((unsigned long) section->sh_entsize == section->sh_entsize)
6433             printf (" %2.2lx", (unsigned long) section->sh_entsize);
6434           else
6435             {
6436               putchar (' ');
6437               print_vma (section->sh_entsize, LONG_HEX);
6438             }
6439
6440           if (do_section_details)
6441             fputs ("  ", stdout);
6442           else
6443             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6444
6445           printf ("%2u %3u ", section->sh_link, section->sh_info);
6446
6447           if ((unsigned long) section->sh_addralign == section->sh_addralign)
6448             printf ("%2lu\n", (unsigned long) section->sh_addralign);
6449           else
6450             {
6451               print_vma (section->sh_addralign, DEC);
6452               putchar ('\n');
6453             }
6454         }
6455       else if (do_section_details)
6456         {
6457           printf ("       %-15.15s  ",
6458                   get_section_type_name (filedata, section->sh_type));
6459           print_vma (section->sh_addr, LONG_HEX);
6460           if ((long) section->sh_offset == section->sh_offset)
6461             printf ("  %16.16lx", (unsigned long) section->sh_offset);
6462           else
6463             {
6464               printf ("  ");
6465               print_vma (section->sh_offset, LONG_HEX);
6466             }
6467           printf ("  %u\n       ", section->sh_link);
6468           print_vma (section->sh_size, LONG_HEX);
6469           putchar (' ');
6470           print_vma (section->sh_entsize, LONG_HEX);
6471
6472           printf ("  %-16u  %lu\n",
6473                   section->sh_info,
6474                   (unsigned long) section->sh_addralign);
6475         }
6476       else
6477         {
6478           putchar (' ');
6479           print_vma (section->sh_addr, LONG_HEX);
6480           if ((long) section->sh_offset == section->sh_offset)
6481             printf ("  %8.8lx", (unsigned long) section->sh_offset);
6482           else
6483             {
6484               printf ("  ");
6485               print_vma (section->sh_offset, LONG_HEX);
6486             }
6487           printf ("\n       ");
6488           print_vma (section->sh_size, LONG_HEX);
6489           printf ("  ");
6490           print_vma (section->sh_entsize, LONG_HEX);
6491
6492           printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6493
6494           printf ("     %2u   %3u     %lu\n",
6495                   section->sh_link,
6496                   section->sh_info,
6497                   (unsigned long) section->sh_addralign);
6498         }
6499
6500       if (do_section_details)
6501         {
6502           printf ("       %s\n", get_elf_section_flags (filedata, section->sh_flags));
6503           if ((section->sh_flags & SHF_COMPRESSED) != 0)
6504             {
6505               /* Minimum section size is 12 bytes for 32-bit compression
6506                  header + 12 bytes for compressed data header.  */
6507               unsigned char buf[24];
6508
6509               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6510               if (get_data (&buf, filedata, section->sh_offset, 1,
6511                             sizeof (buf), _("compression header")))
6512                 {
6513                   Elf_Internal_Chdr chdr;
6514
6515                   (void) get_compression_header (&chdr, buf, sizeof (buf));
6516
6517                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6518                     printf ("       ZLIB, ");
6519                   else
6520                     printf (_("       [<unknown>: 0x%x], "),
6521                             chdr.ch_type);
6522                   print_vma (chdr.ch_size, LONG_HEX);
6523                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6524                 }
6525             }
6526         }
6527     }
6528
6529   if (!do_section_details)
6530     {
6531       /* The ordering of the letters shown here matches the ordering of the
6532          corresponding SHF_xxx values, and hence the order in which these
6533          letters will be displayed to the user.  */
6534       printf (_("Key to Flags:\n\
6535   W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6536   L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6537   C (compressed), x (unknown), o (OS specific), E (exclude),\n  "));
6538       if (filedata->file_header.e_machine == EM_X86_64
6539           || filedata->file_header.e_machine == EM_L1OM
6540           || filedata->file_header.e_machine == EM_K1OM)
6541         printf (_("l (large), "));
6542       else if (filedata->file_header.e_machine == EM_ARM)
6543         printf (_("y (purecode), "));
6544       else if (filedata->file_header.e_machine == EM_PPC)
6545         printf (_("v (VLE), "));
6546       printf ("p (processor specific)\n");
6547     }
6548
6549   return TRUE;
6550 }
6551
6552 static const char *
6553 get_group_flags (unsigned int flags)
6554 {
6555   static char buff[128];
6556
6557   if (flags == 0)
6558     return "";
6559   else if (flags == GRP_COMDAT)
6560     return "COMDAT ";
6561
6562   snprintf (buff, 14, _("[0x%x: "), flags);
6563
6564   flags &= ~ GRP_COMDAT;
6565   if (flags & GRP_MASKOS)
6566     {
6567       strcat (buff, "<OS specific>");
6568       flags &= ~ GRP_MASKOS;
6569     }
6570
6571   if (flags & GRP_MASKPROC)
6572     {
6573       strcat (buff, "<PROC specific>");
6574       flags &= ~ GRP_MASKPROC;
6575     }
6576
6577   if (flags)
6578     strcat (buff, "<unknown>");
6579
6580   strcat (buff, "]");
6581   return buff;
6582 }
6583
6584 static bfd_boolean
6585 process_section_groups (Filedata * filedata)
6586 {
6587   Elf_Internal_Shdr * section;
6588   unsigned int i;
6589   struct group * group;
6590   Elf_Internal_Shdr * symtab_sec;
6591   Elf_Internal_Shdr * strtab_sec;
6592   Elf_Internal_Sym * symtab;
6593   unsigned long num_syms;
6594   char * strtab;
6595   size_t strtab_size;
6596
6597   /* Don't process section groups unless needed.  */
6598   if (!do_unwind && !do_section_groups)
6599     return TRUE;
6600
6601   if (filedata->file_header.e_shnum == 0)
6602     {
6603       if (do_section_groups)
6604         printf (_("\nThere are no sections to group in this file.\n"));
6605
6606       return TRUE;
6607     }
6608
6609   if (filedata->section_headers == NULL)
6610     {
6611       error (_("Section headers are not available!\n"));
6612       /* PR 13622: This can happen with a corrupt ELF header.  */
6613       return FALSE;
6614     }
6615
6616   section_headers_groups = (struct group **) calloc (filedata->file_header.e_shnum,
6617                                                      sizeof (struct group *));
6618
6619   if (section_headers_groups == NULL)
6620     {
6621       error (_("Out of memory reading %u section group headers\n"),
6622              filedata->file_header.e_shnum);
6623       return FALSE;
6624     }
6625
6626   /* Scan the sections for the group section.  */
6627   group_count = 0;
6628   for (i = 0, section = filedata->section_headers;
6629        i < filedata->file_header.e_shnum;
6630        i++, section++)
6631     if (section->sh_type == SHT_GROUP)
6632       group_count++;
6633
6634   if (group_count == 0)
6635     {
6636       if (do_section_groups)
6637         printf (_("\nThere are no section groups in this file.\n"));
6638
6639       return TRUE;
6640     }
6641
6642   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6643
6644   if (section_groups == NULL)
6645     {
6646       error (_("Out of memory reading %lu groups\n"),
6647              (unsigned long) group_count);
6648       return FALSE;
6649     }
6650
6651   symtab_sec = NULL;
6652   strtab_sec = NULL;
6653   symtab = NULL;
6654   num_syms = 0;
6655   strtab = NULL;
6656   strtab_size = 0;
6657   for (i = 0, section = filedata->section_headers, group = section_groups;
6658        i < filedata->file_header.e_shnum;
6659        i++, section++)
6660     {
6661       if (section->sh_type == SHT_GROUP)
6662         {
6663           const char * name = printable_section_name (filedata, section);
6664           const char * group_name;
6665           unsigned char * start;
6666           unsigned char * indices;
6667           unsigned int entry, j, size;
6668           Elf_Internal_Shdr * sec;
6669           Elf_Internal_Sym * sym;
6670
6671           /* Get the symbol table.  */
6672           if (section->sh_link >= filedata->file_header.e_shnum
6673               || ((sec = filedata->section_headers + section->sh_link)->sh_type
6674                   != SHT_SYMTAB))
6675             {
6676               error (_("Bad sh_link in group section `%s'\n"), name);
6677               continue;
6678             }
6679
6680           if (symtab_sec != sec)
6681             {
6682               symtab_sec = sec;
6683               if (symtab)
6684                 free (symtab);
6685               symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
6686             }
6687
6688           if (symtab == NULL)
6689             {
6690               error (_("Corrupt header in group section `%s'\n"), name);
6691               continue;
6692             }
6693
6694           if (section->sh_info >= num_syms)
6695             {
6696               error (_("Bad sh_info in group section `%s'\n"), name);
6697               continue;
6698             }
6699
6700           sym = symtab + section->sh_info;
6701
6702           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6703             {
6704               if (sym->st_shndx == 0
6705                   || sym->st_shndx >= filedata->file_header.e_shnum)
6706                 {
6707                   error (_("Bad sh_info in group section `%s'\n"), name);
6708                   continue;
6709                 }
6710
6711               group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
6712               strtab_sec = NULL;
6713               if (strtab)
6714                 free (strtab);
6715               strtab = NULL;
6716               strtab_size = 0;
6717             }
6718           else
6719             {
6720               /* Get the string table.  */
6721               if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
6722                 {
6723                   strtab_sec = NULL;
6724                   if (strtab)
6725                     free (strtab);
6726                   strtab = NULL;
6727                   strtab_size = 0;
6728                 }
6729               else if (strtab_sec
6730                        != (sec = filedata->section_headers + symtab_sec->sh_link))
6731                 {
6732                   strtab_sec = sec;
6733                   if (strtab)
6734                     free (strtab);
6735
6736                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
6737                                               1, strtab_sec->sh_size,
6738                                               _("string table"));
6739                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6740                 }
6741               group_name = sym->st_name < strtab_size
6742                 ? strtab + sym->st_name : _("<corrupt>");
6743             }
6744
6745           /* PR 17531: file: loop.  */
6746           if (section->sh_entsize > section->sh_size)
6747             {
6748               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6749                      printable_section_name (filedata, section),
6750                      (unsigned long) section->sh_entsize,
6751                      (unsigned long) section->sh_size);
6752               break;
6753             }
6754
6755           start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
6756                                               1, section->sh_size,
6757                                               _("section data"));
6758           if (start == NULL)
6759             continue;
6760
6761           indices = start;
6762           size = (section->sh_size / section->sh_entsize) - 1;
6763           entry = byte_get (indices, 4);
6764           indices += 4;
6765
6766           if (do_section_groups)
6767             {
6768               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6769                       get_group_flags (entry), i, name, group_name, size);
6770
6771               printf (_("   [Index]    Name\n"));
6772             }
6773
6774           group->group_index = i;
6775
6776           for (j = 0; j < size; j++)
6777             {
6778               struct group_list * g;
6779
6780               entry = byte_get (indices, 4);
6781               indices += 4;
6782
6783               if (entry >= filedata->file_header.e_shnum)
6784                 {
6785                   static unsigned num_group_errors = 0;
6786
6787                   if (num_group_errors ++ < 10)
6788                     {
6789                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6790                              entry, i, filedata->file_header.e_shnum - 1);
6791                       if (num_group_errors == 10)
6792                         warn (_("Further error messages about overlarge group section indicies suppressed\n"));
6793                     }
6794                   continue;
6795                 }
6796
6797               if (section_headers_groups [entry] != NULL)
6798                 {
6799                   if (entry)
6800                     {
6801                       static unsigned num_errs = 0;
6802
6803                       if (num_errs ++ < 10)
6804                         {
6805                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6806                                  entry, i,
6807                                  section_headers_groups [entry]->group_index);
6808                           if (num_errs == 10)
6809                             warn (_("Further error messages about already contained group sections suppressed\n"));
6810                         }
6811                       continue;
6812                     }
6813                   else
6814                     {
6815                       /* Intel C/C++ compiler may put section 0 in a
6816                          section group.  We just warn it the first time
6817                          and ignore it afterwards.  */
6818                       static bfd_boolean warned = FALSE;
6819                       if (!warned)
6820                         {
6821                           error (_("section 0 in group section [%5u]\n"),
6822                                  section_headers_groups [entry]->group_index);
6823                           warned = TRUE;
6824                         }
6825                     }
6826                 }
6827
6828               section_headers_groups [entry] = group;
6829
6830               if (do_section_groups)
6831                 {
6832                   sec = filedata->section_headers + entry;
6833                   printf ("   [%5u]   %s\n", entry, printable_section_name (filedata, sec));
6834                 }
6835
6836               g = (struct group_list *) xmalloc (sizeof (struct group_list));
6837               g->section_index = entry;
6838               g->next = group->root;
6839               group->root = g;
6840             }
6841
6842           if (start)
6843             free (start);
6844
6845           group++;
6846         }
6847     }
6848
6849   if (symtab)
6850     free (symtab);
6851   if (strtab)
6852     free (strtab);
6853   return TRUE;
6854 }
6855
6856 /* Data used to display dynamic fixups.  */
6857
6858 struct ia64_vms_dynfixup
6859 {
6860   bfd_vma needed_ident;         /* Library ident number.  */
6861   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
6862   bfd_vma fixup_needed;         /* Index of the library.  */
6863   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
6864   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
6865 };
6866
6867 /* Data used to display dynamic relocations.  */
6868
6869 struct ia64_vms_dynimgrela
6870 {
6871   bfd_vma img_rela_cnt;         /* Number of relocations.  */
6872   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
6873 };
6874
6875 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6876    library).  */
6877
6878 static bfd_boolean
6879 dump_ia64_vms_dynamic_fixups (Filedata *                  filedata,
6880                               struct ia64_vms_dynfixup *  fixup,
6881                               const char *                strtab,
6882                               unsigned int                strtab_sz)
6883 {
6884   Elf64_External_VMS_IMAGE_FIXUP * imfs;
6885   long i;
6886   const char * lib_name;
6887
6888   imfs = get_data (NULL, filedata, dynamic_addr + fixup->fixup_rela_off,
6889                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
6890                    _("dynamic section image fixups"));
6891   if (!imfs)
6892     return FALSE;
6893
6894   if (fixup->needed < strtab_sz)
6895     lib_name = strtab + fixup->needed;
6896   else
6897     {
6898       warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6899             (unsigned long) fixup->needed);
6900       lib_name = "???";
6901     }
6902   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6903           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6904   printf
6905     (_("Seg Offset           Type                             SymVec DataType\n"));
6906
6907   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6908     {
6909       unsigned int type;
6910       const char *rtype;
6911
6912       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6913       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6914       type = BYTE_GET (imfs [i].type);
6915       rtype = elf_ia64_reloc_type (type);
6916       if (rtype == NULL)
6917         printf (" 0x%08x                       ", type);
6918       else
6919         printf (" %-32s ", rtype);
6920       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6921       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6922     }
6923
6924   free (imfs);
6925   return TRUE;
6926 }
6927
6928 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
6929
6930 static bfd_boolean
6931 dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
6932 {
6933   Elf64_External_VMS_IMAGE_RELA *imrs;
6934   long i;
6935
6936   imrs = get_data (NULL, filedata, dynamic_addr + imgrela->img_rela_off,
6937                    1, imgrela->img_rela_cnt * sizeof (*imrs),
6938                    _("dynamic section image relocations"));
6939   if (!imrs)
6940     return FALSE;
6941
6942   printf (_("\nImage relocs\n"));
6943   printf
6944     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
6945
6946   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6947     {
6948       unsigned int type;
6949       const char *rtype;
6950
6951       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6952       printf ("%08" BFD_VMA_FMT "x ",
6953               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6954       type = BYTE_GET (imrs [i].type);
6955       rtype = elf_ia64_reloc_type (type);
6956       if (rtype == NULL)
6957         printf ("0x%08x                      ", type);
6958       else
6959         printf ("%-31s ", rtype);
6960       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6961       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6962       printf ("%08" BFD_VMA_FMT "x\n",
6963               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6964     }
6965
6966   free (imrs);
6967   return TRUE;
6968 }
6969
6970 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
6971
6972 static bfd_boolean
6973 process_ia64_vms_dynamic_relocs (Filedata * filedata)
6974 {
6975   struct ia64_vms_dynfixup fixup;
6976   struct ia64_vms_dynimgrela imgrela;
6977   Elf_Internal_Dyn *entry;
6978   bfd_vma strtab_off = 0;
6979   bfd_vma strtab_sz = 0;
6980   char *strtab = NULL;
6981   bfd_boolean res = TRUE;
6982
6983   memset (&fixup, 0, sizeof (fixup));
6984   memset (&imgrela, 0, sizeof (imgrela));
6985
6986   /* Note: the order of the entries is specified by the OpenVMS specs.  */
6987   for (entry = dynamic_section;
6988        entry < dynamic_section + dynamic_nent;
6989        entry++)
6990     {
6991       switch (entry->d_tag)
6992         {
6993         case DT_IA_64_VMS_STRTAB_OFFSET:
6994           strtab_off = entry->d_un.d_val;
6995           break;
6996         case DT_STRSZ:
6997           strtab_sz = entry->d_un.d_val;
6998           if (strtab == NULL)
6999             strtab = get_data (NULL, filedata, dynamic_addr + strtab_off,
7000                                1, strtab_sz, _("dynamic string section"));
7001           break;
7002
7003         case DT_IA_64_VMS_NEEDED_IDENT:
7004           fixup.needed_ident = entry->d_un.d_val;
7005           break;
7006         case DT_NEEDED:
7007           fixup.needed = entry->d_un.d_val;
7008           break;
7009         case DT_IA_64_VMS_FIXUP_NEEDED:
7010           fixup.fixup_needed = entry->d_un.d_val;
7011           break;
7012         case DT_IA_64_VMS_FIXUP_RELA_CNT:
7013           fixup.fixup_rela_cnt = entry->d_un.d_val;
7014           break;
7015         case DT_IA_64_VMS_FIXUP_RELA_OFF:
7016           fixup.fixup_rela_off = entry->d_un.d_val;
7017           if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7018             res = FALSE;
7019           break;
7020         case DT_IA_64_VMS_IMG_RELA_CNT:
7021           imgrela.img_rela_cnt = entry->d_un.d_val;
7022           break;
7023         case DT_IA_64_VMS_IMG_RELA_OFF:
7024           imgrela.img_rela_off = entry->d_un.d_val;
7025           if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7026             res = FALSE;
7027           break;
7028
7029         default:
7030           break;
7031         }
7032     }
7033
7034   if (strtab != NULL)
7035     free (strtab);
7036
7037   return res;
7038 }
7039
7040 static struct
7041 {
7042   const char * name;
7043   int reloc;
7044   int size;
7045   int rela;
7046 }
7047   dynamic_relocations [] =
7048 {
7049   { "REL", DT_REL, DT_RELSZ, FALSE },
7050   { "RELA", DT_RELA, DT_RELASZ, TRUE },
7051   { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7052 };
7053
7054 /* Process the reloc section.  */
7055
7056 static bfd_boolean
7057 process_relocs (Filedata * filedata)
7058 {
7059   unsigned long rel_size;
7060   unsigned long rel_offset;
7061
7062   if (!do_reloc)
7063     return TRUE;
7064
7065   if (do_using_dynamic)
7066     {
7067       int          is_rela;
7068       const char * name;
7069       bfd_boolean  has_dynamic_reloc;
7070       unsigned int i;
7071
7072       has_dynamic_reloc = FALSE;
7073
7074       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7075         {
7076           is_rela = dynamic_relocations [i].rela;
7077           name = dynamic_relocations [i].name;
7078           rel_size = dynamic_info [dynamic_relocations [i].size];
7079           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7080
7081           if (rel_size)
7082             has_dynamic_reloc = TRUE;
7083
7084           if (is_rela == UNKNOWN)
7085             {
7086               if (dynamic_relocations [i].reloc == DT_JMPREL)
7087                 switch (dynamic_info[DT_PLTREL])
7088                   {
7089                   case DT_REL:
7090                     is_rela = FALSE;
7091                     break;
7092                   case DT_RELA:
7093                     is_rela = TRUE;
7094                     break;
7095                   }
7096             }
7097
7098           if (rel_size)
7099             {
7100               printf
7101                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7102                  name, rel_offset, rel_size);
7103
7104               dump_relocations (filedata,
7105                                 offset_from_vma (filedata, rel_offset, rel_size),
7106                                 rel_size,
7107                                 dynamic_symbols, num_dynamic_syms,
7108                                 dynamic_strings, dynamic_strings_length,
7109                                 is_rela, TRUE /* is_dynamic */);
7110             }
7111         }
7112
7113       if (is_ia64_vms (filedata))
7114         if (process_ia64_vms_dynamic_relocs (filedata))
7115           has_dynamic_reloc = TRUE;
7116
7117       if (! has_dynamic_reloc)
7118         printf (_("\nThere are no dynamic relocations in this file.\n"));
7119     }
7120   else
7121     {
7122       Elf_Internal_Shdr * section;
7123       unsigned long i;
7124       bfd_boolean found = FALSE;
7125
7126       for (i = 0, section = filedata->section_headers;
7127            i < filedata->file_header.e_shnum;
7128            i++, section++)
7129         {
7130           if (   section->sh_type != SHT_RELA
7131               && section->sh_type != SHT_REL)
7132             continue;
7133
7134           rel_offset = section->sh_offset;
7135           rel_size   = section->sh_size;
7136
7137           if (rel_size)
7138             {
7139               Elf_Internal_Shdr * strsec;
7140               int is_rela;
7141               unsigned long num_rela;
7142
7143               printf (_("\nRelocation section "));
7144
7145               if (filedata->string_table == NULL)
7146                 printf ("%d", section->sh_name);
7147               else
7148                 printf ("'%s'", printable_section_name (filedata, section));
7149
7150               num_rela = rel_size / section->sh_entsize;
7151               printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7152                                 " at offset 0x%lx contains %lu entries:\n",
7153                                 num_rela),
7154                       rel_offset, num_rela);
7155
7156               is_rela = section->sh_type == SHT_RELA;
7157
7158               if (section->sh_link != 0
7159                   && section->sh_link < filedata->file_header.e_shnum)
7160                 {
7161                   Elf_Internal_Shdr * symsec;
7162                   Elf_Internal_Sym *  symtab;
7163                   unsigned long nsyms;
7164                   unsigned long strtablen = 0;
7165                   char * strtab = NULL;
7166
7167                   symsec = filedata->section_headers + section->sh_link;
7168                   if (symsec->sh_type != SHT_SYMTAB
7169                       && symsec->sh_type != SHT_DYNSYM)
7170                     continue;
7171
7172                   symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
7173
7174                   if (symtab == NULL)
7175                     continue;
7176
7177                   if (symsec->sh_link != 0
7178                       && symsec->sh_link < filedata->file_header.e_shnum)
7179                     {
7180                       strsec = filedata->section_headers + symsec->sh_link;
7181
7182                       strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7183                                                   1, strsec->sh_size,
7184                                                   _("string table"));
7185                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
7186                     }
7187
7188                   dump_relocations (filedata, rel_offset, rel_size,
7189                                     symtab, nsyms, strtab, strtablen,
7190                                     is_rela,
7191                                     symsec->sh_type == SHT_DYNSYM);
7192                   if (strtab)
7193                     free (strtab);
7194                   free (symtab);
7195                 }
7196               else
7197                 dump_relocations (filedata, rel_offset, rel_size,
7198                                   NULL, 0, NULL, 0, is_rela,
7199                                   FALSE /* is_dynamic */);
7200
7201               found = TRUE;
7202             }
7203         }
7204
7205       if (! found)
7206         {
7207           /* Users sometimes forget the -D option, so try to be helpful.  */
7208           for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7209             {
7210               if (dynamic_info [dynamic_relocations [i].size])
7211                 {
7212                   printf (_("\nThere are no static relocations in this file."));
7213                   printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7214
7215                   break;
7216                 }
7217             }
7218           if (i == ARRAY_SIZE (dynamic_relocations))
7219             printf (_("\nThere are no relocations in this file.\n"));
7220         }
7221     }
7222
7223   return TRUE;
7224 }
7225
7226 /* An absolute address consists of a section and an offset.  If the
7227    section is NULL, the offset itself is the address, otherwise, the
7228    address equals to LOAD_ADDRESS(section) + offset.  */
7229
7230 struct absaddr
7231 {
7232   unsigned short section;
7233   bfd_vma offset;
7234 };
7235
7236 #define ABSADDR(a) \
7237   ((a).section \
7238    ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7239    : (a).offset)
7240
7241 /* Find the nearest symbol at or below ADDR.  Returns the symbol
7242    name, if found, and the offset from the symbol to ADDR.  */
7243
7244 static void
7245 find_symbol_for_address (Filedata *          filedata,
7246                          Elf_Internal_Sym *  symtab,
7247                          unsigned long       nsyms,
7248                          const char *        strtab,
7249                          unsigned long       strtab_size,
7250                          struct absaddr      addr,
7251                          const char **       symname,
7252                          bfd_vma *           offset)
7253 {
7254   bfd_vma dist = 0x100000;
7255   Elf_Internal_Sym * sym;
7256   Elf_Internal_Sym * beg;
7257   Elf_Internal_Sym * end;
7258   Elf_Internal_Sym * best = NULL;
7259
7260   REMOVE_ARCH_BITS (addr.offset);
7261   beg = symtab;
7262   end = symtab + nsyms;
7263
7264   while (beg < end)
7265     {
7266       bfd_vma value;
7267
7268       sym = beg + (end - beg) / 2;
7269
7270       value = sym->st_value;
7271       REMOVE_ARCH_BITS (value);
7272
7273       if (sym->st_name != 0
7274           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7275           && addr.offset >= value
7276           && addr.offset - value < dist)
7277         {
7278           best = sym;
7279           dist = addr.offset - value;
7280           if (!dist)
7281             break;
7282         }
7283
7284       if (addr.offset < value)
7285         end = sym;
7286       else
7287         beg = sym + 1;
7288     }
7289
7290   if (best)
7291     {
7292       *symname = (best->st_name >= strtab_size
7293                   ? _("<corrupt>") : strtab + best->st_name);
7294       *offset = dist;
7295       return;
7296     }
7297
7298   *symname = NULL;
7299   *offset = addr.offset;
7300 }
7301
7302 static /* signed */ int
7303 symcmp (const void *p, const void *q)
7304 {
7305   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7306   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7307
7308   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7309 }
7310
7311 /* Process the unwind section.  */
7312
7313 #include "unwind-ia64.h"
7314
7315 struct ia64_unw_table_entry
7316 {
7317   struct absaddr start;
7318   struct absaddr end;
7319   struct absaddr info;
7320 };
7321
7322 struct ia64_unw_aux_info
7323 {
7324   struct ia64_unw_table_entry * table;          /* Unwind table.  */
7325   unsigned long                 table_len;      /* Length of unwind table.  */
7326   unsigned char *               info;           /* Unwind info.  */
7327   unsigned long                 info_size;      /* Size of unwind info.  */
7328   bfd_vma                       info_addr;      /* Starting address of unwind info.  */
7329   bfd_vma                       seg_base;       /* Starting address of segment.  */
7330   Elf_Internal_Sym *            symtab;         /* The symbol table.  */
7331   unsigned long                 nsyms;          /* Number of symbols.  */
7332   Elf_Internal_Sym *            funtab;         /* Sorted table of STT_FUNC symbols.  */
7333   unsigned long                 nfuns;          /* Number of entries in funtab.  */
7334   char *                        strtab;         /* The string table.  */
7335   unsigned long                 strtab_size;    /* Size of string table.  */
7336 };
7337
7338 static bfd_boolean
7339 dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7340 {
7341   struct ia64_unw_table_entry * tp;
7342   unsigned long j, nfuns;
7343   int in_body;
7344   bfd_boolean res = TRUE;
7345
7346   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7347   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7348     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7349       aux->funtab[nfuns++] = aux->symtab[j];
7350   aux->nfuns = nfuns;
7351   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7352
7353   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7354     {
7355       bfd_vma stamp;
7356       bfd_vma offset;
7357       const unsigned char * dp;
7358       const unsigned char * head;
7359       const unsigned char * end;
7360       const char * procname;
7361
7362       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7363                                aux->strtab_size, tp->start, &procname, &offset);
7364
7365       fputs ("\n<", stdout);
7366
7367       if (procname)
7368         {
7369           fputs (procname, stdout);
7370
7371           if (offset)
7372             printf ("+%lx", (unsigned long) offset);
7373         }
7374
7375       fputs (">: [", stdout);
7376       print_vma (tp->start.offset, PREFIX_HEX);
7377       fputc ('-', stdout);
7378       print_vma (tp->end.offset, PREFIX_HEX);
7379       printf ("], info at +0x%lx\n",
7380               (unsigned long) (tp->info.offset - aux->seg_base));
7381
7382       /* PR 17531: file: 86232b32.  */
7383       if (aux->info == NULL)
7384         continue;
7385
7386       /* PR 17531: file: 0997b4d1.  */
7387       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7388         {
7389           warn (_("Invalid offset %lx in table entry %ld\n"),
7390                 (long) tp->info.offset, (long) (tp - aux->table));
7391           res = FALSE;
7392           continue;
7393         }
7394
7395       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7396       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7397
7398       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7399               (unsigned) UNW_VER (stamp),
7400               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7401               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7402               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7403               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7404
7405       if (UNW_VER (stamp) != 1)
7406         {
7407           printf (_("\tUnknown version.\n"));
7408           continue;
7409         }
7410
7411       in_body = 0;
7412       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7413       /* PR 17531: file: 16ceda89.  */
7414       if (end > aux->info + aux->info_size)
7415         end = aux->info + aux->info_size;
7416       for (dp = head + 8; dp < end;)
7417         dp = unw_decode (dp, in_body, & in_body, end);
7418     }
7419
7420   free (aux->funtab);
7421
7422   return res;
7423 }
7424
7425 static bfd_boolean
7426 slurp_ia64_unwind_table (Filedata *                  filedata,
7427                          struct ia64_unw_aux_info *  aux,
7428                          Elf_Internal_Shdr *         sec)
7429 {
7430   unsigned long size, nrelas, i;
7431   Elf_Internal_Phdr * seg;
7432   struct ia64_unw_table_entry * tep;
7433   Elf_Internal_Shdr * relsec;
7434   Elf_Internal_Rela * rela;
7435   Elf_Internal_Rela * rp;
7436   unsigned char * table;
7437   unsigned char * tp;
7438   Elf_Internal_Sym * sym;
7439   const char * relname;
7440
7441   aux->table_len = 0;
7442
7443   /* First, find the starting address of the segment that includes
7444      this section: */
7445
7446   if (filedata->file_header.e_phnum)
7447     {
7448       if (! get_program_headers (filedata))
7449           return FALSE;
7450
7451       for (seg = filedata->program_headers;
7452            seg < filedata->program_headers + filedata->file_header.e_phnum;
7453            ++seg)
7454         {
7455           if (seg->p_type != PT_LOAD)
7456             continue;
7457
7458           if (sec->sh_addr >= seg->p_vaddr
7459               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7460             {
7461               aux->seg_base = seg->p_vaddr;
7462               break;
7463             }
7464         }
7465     }
7466
7467   /* Second, build the unwind table from the contents of the unwind section:  */
7468   size = sec->sh_size;
7469   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7470                                       _("unwind table"));
7471   if (!table)
7472     return FALSE;
7473
7474   aux->table_len = size / (3 * eh_addr_size);
7475   aux->table = (struct ia64_unw_table_entry *)
7476     xcmalloc (aux->table_len, sizeof (aux->table[0]));
7477   tep = aux->table;
7478
7479   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7480     {
7481       tep->start.section = SHN_UNDEF;
7482       tep->end.section   = SHN_UNDEF;
7483       tep->info.section  = SHN_UNDEF;
7484       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7485       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7486       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7487       tep->start.offset += aux->seg_base;
7488       tep->end.offset   += aux->seg_base;
7489       tep->info.offset  += aux->seg_base;
7490     }
7491   free (table);
7492
7493   /* Third, apply any relocations to the unwind table:  */
7494   for (relsec = filedata->section_headers;
7495        relsec < filedata->section_headers + filedata->file_header.e_shnum;
7496        ++relsec)
7497     {
7498       if (relsec->sh_type != SHT_RELA
7499           || relsec->sh_info >= filedata->file_header.e_shnum
7500           || filedata->section_headers + relsec->sh_info != sec)
7501         continue;
7502
7503       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7504                               & rela, & nrelas))
7505         {
7506           free (aux->table);
7507           aux->table = NULL;
7508           aux->table_len = 0;
7509           return FALSE;
7510         }
7511
7512       for (rp = rela; rp < rela + nrelas; ++rp)
7513         {
7514           relname = elf_ia64_reloc_type (get_reloc_type (filedata, rp->r_info));
7515           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7516
7517           /* PR 17531: file: 9fa67536.  */
7518           if (relname == NULL)
7519             {
7520               warn (_("Skipping unknown relocation type: %u\n"),
7521                     get_reloc_type (filedata, rp->r_info));
7522               continue;
7523             }
7524
7525           if (! const_strneq (relname, "R_IA64_SEGREL"))
7526             {
7527               warn (_("Skipping unexpected relocation type: %s\n"), relname);
7528               continue;
7529             }
7530
7531           i = rp->r_offset / (3 * eh_addr_size);
7532
7533           /* PR 17531: file: 5bc8d9bf.  */
7534           if (i >= aux->table_len)
7535             {
7536               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7537               continue;
7538             }
7539
7540           switch (rp->r_offset / eh_addr_size % 3)
7541             {
7542             case 0:
7543               aux->table[i].start.section = sym->st_shndx;
7544               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
7545               break;
7546             case 1:
7547               aux->table[i].end.section   = sym->st_shndx;
7548               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
7549               break;
7550             case 2:
7551               aux->table[i].info.section  = sym->st_shndx;
7552               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
7553               break;
7554             default:
7555               break;
7556             }
7557         }
7558
7559       free (rela);
7560     }
7561
7562   return TRUE;
7563 }
7564
7565 static bfd_boolean
7566 ia64_process_unwind (Filedata * filedata)
7567 {
7568   Elf_Internal_Shdr * sec;
7569   Elf_Internal_Shdr * unwsec = NULL;
7570   Elf_Internal_Shdr * strsec;
7571   unsigned long i, unwcount = 0, unwstart = 0;
7572   struct ia64_unw_aux_info aux;
7573   bfd_boolean res = TRUE;
7574
7575   memset (& aux, 0, sizeof (aux));
7576
7577   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7578     {
7579       if (sec->sh_type == SHT_SYMTAB
7580           && sec->sh_link < filedata->file_header.e_shnum)
7581         {
7582           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
7583
7584           strsec = filedata->section_headers + sec->sh_link;
7585           if (aux.strtab != NULL)
7586             {
7587               error (_("Multiple auxillary string tables encountered\n"));
7588               free (aux.strtab);
7589               res = FALSE;
7590             }
7591           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7592                                           1, strsec->sh_size,
7593                                           _("string table"));
7594           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7595         }
7596       else if (sec->sh_type == SHT_IA_64_UNWIND)
7597         unwcount++;
7598     }
7599
7600   if (!unwcount)
7601     printf (_("\nThere are no unwind sections in this file.\n"));
7602
7603   while (unwcount-- > 0)
7604     {
7605       char * suffix;
7606       size_t len, len2;
7607
7608       for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7609            i < filedata->file_header.e_shnum; ++i, ++sec)
7610         if (sec->sh_type == SHT_IA_64_UNWIND)
7611           {
7612             unwsec = sec;
7613             break;
7614           }
7615       /* We have already counted the number of SHT_IA64_UNWIND
7616          sections so the loop above should never fail.  */
7617       assert (unwsec != NULL);
7618
7619       unwstart = i + 1;
7620       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7621
7622       if ((unwsec->sh_flags & SHF_GROUP) != 0)
7623         {
7624           /* We need to find which section group it is in.  */
7625           struct group_list * g;
7626
7627           if (section_headers_groups == NULL
7628               || section_headers_groups [i] == NULL)
7629             i = filedata->file_header.e_shnum;
7630           else
7631             {
7632               g = section_headers_groups [i]->root;
7633
7634               for (; g != NULL; g = g->next)
7635                 {
7636                   sec = filedata->section_headers + g->section_index;
7637
7638                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7639                     break;
7640                 }
7641
7642               if (g == NULL)
7643                 i = filedata->file_header.e_shnum;
7644             }
7645         }
7646       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7647         {
7648           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
7649           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7650           suffix = SECTION_NAME (unwsec) + len;
7651           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7652                ++i, ++sec)
7653             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7654                 && streq (SECTION_NAME (sec) + len2, suffix))
7655               break;
7656         }
7657       else
7658         {
7659           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7660              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
7661           len = sizeof (ELF_STRING_ia64_unwind) - 1;
7662           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7663           suffix = "";
7664           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7665             suffix = SECTION_NAME (unwsec) + len;
7666           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7667                ++i, ++sec)
7668             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7669                 && streq (SECTION_NAME (sec) + len2, suffix))
7670               break;
7671         }
7672
7673       if (i == filedata->file_header.e_shnum)
7674         {
7675           printf (_("\nCould not find unwind info section for "));
7676
7677           if (filedata->string_table == NULL)
7678             printf ("%d", unwsec->sh_name);
7679           else
7680             printf ("'%s'", printable_section_name (filedata, unwsec));
7681         }
7682       else
7683         {
7684           aux.info_addr = sec->sh_addr;
7685           aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
7686                                                  sec->sh_size,
7687                                                  _("unwind info"));
7688           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7689
7690           printf (_("\nUnwind section "));
7691
7692           if (filedata->string_table == NULL)
7693             printf ("%d", unwsec->sh_name);
7694           else
7695             printf ("'%s'", printable_section_name (filedata, unwsec));
7696
7697           printf (_(" at offset 0x%lx contains %lu entries:\n"),
7698                   (unsigned long) unwsec->sh_offset,
7699                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7700
7701           if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
7702               && aux.table_len > 0)
7703             dump_ia64_unwind (filedata, & aux);
7704
7705           if (aux.table)
7706             free ((char *) aux.table);
7707           if (aux.info)
7708             free ((char *) aux.info);
7709           aux.table = NULL;
7710           aux.info = NULL;
7711         }
7712     }
7713
7714   if (aux.symtab)
7715     free (aux.symtab);
7716   if (aux.strtab)
7717     free ((char *) aux.strtab);
7718
7719   return res;
7720 }
7721
7722 struct hppa_unw_table_entry
7723 {
7724   struct absaddr start;
7725   struct absaddr end;
7726   unsigned int Cannot_unwind:1;                 /* 0 */
7727   unsigned int Millicode:1;                     /* 1 */
7728   unsigned int Millicode_save_sr0:1;            /* 2 */
7729   unsigned int Region_description:2;            /* 3..4 */
7730   unsigned int reserved1:1;                     /* 5 */
7731   unsigned int Entry_SR:1;                      /* 6 */
7732   unsigned int Entry_FR:4;     /* Number saved     7..10 */
7733   unsigned int Entry_GR:5;     /* Number saved     11..15 */
7734   unsigned int Args_stored:1;                   /* 16 */
7735   unsigned int Variable_Frame:1;                /* 17 */
7736   unsigned int Separate_Package_Body:1;         /* 18 */
7737   unsigned int Frame_Extension_Millicode:1;     /* 19 */
7738   unsigned int Stack_Overflow_Check:1;          /* 20 */
7739   unsigned int Two_Instruction_SP_Increment:1;  /* 21 */
7740   unsigned int Ada_Region:1;                    /* 22 */
7741   unsigned int cxx_info:1;                      /* 23 */
7742   unsigned int cxx_try_catch:1;                 /* 24 */
7743   unsigned int sched_entry_seq:1;               /* 25 */
7744   unsigned int reserved2:1;                     /* 26 */
7745   unsigned int Save_SP:1;                       /* 27 */
7746   unsigned int Save_RP:1;                       /* 28 */
7747   unsigned int Save_MRP_in_frame:1;             /* 29 */
7748   unsigned int extn_ptr_defined:1;              /* 30 */
7749   unsigned int Cleanup_defined:1;               /* 31 */
7750
7751   unsigned int MPE_XL_interrupt_marker:1;       /* 0 */
7752   unsigned int HP_UX_interrupt_marker:1;        /* 1 */
7753   unsigned int Large_frame:1;                   /* 2 */
7754   unsigned int Pseudo_SP_Set:1;                 /* 3 */
7755   unsigned int reserved4:1;                     /* 4 */
7756   unsigned int Total_frame_size:27;             /* 5..31 */
7757 };
7758
7759 struct hppa_unw_aux_info
7760 {
7761   struct hppa_unw_table_entry *  table;         /* Unwind table.  */
7762   unsigned long                  table_len;     /* Length of unwind table.  */
7763   bfd_vma                        seg_base;      /* Starting address of segment.  */
7764   Elf_Internal_Sym *             symtab;        /* The symbol table.  */
7765   unsigned long                  nsyms;         /* Number of symbols.  */
7766   Elf_Internal_Sym *             funtab;        /* Sorted table of STT_FUNC symbols.  */
7767   unsigned long                  nfuns;         /* Number of entries in funtab.  */
7768   char *                         strtab;        /* The string table.  */
7769   unsigned long                  strtab_size;   /* Size of string table.  */
7770 };
7771
7772 static bfd_boolean
7773 dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
7774 {
7775   struct hppa_unw_table_entry * tp;
7776   unsigned long j, nfuns;
7777   bfd_boolean res = TRUE;
7778
7779   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7780   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7781     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7782       aux->funtab[nfuns++] = aux->symtab[j];
7783   aux->nfuns = nfuns;
7784   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7785
7786   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7787     {
7788       bfd_vma offset;
7789       const char * procname;
7790
7791       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7792                                aux->strtab_size, tp->start, &procname,
7793                                &offset);
7794
7795       fputs ("\n<", stdout);
7796
7797       if (procname)
7798         {
7799           fputs (procname, stdout);
7800
7801           if (offset)
7802             printf ("+%lx", (unsigned long) offset);
7803         }
7804
7805       fputs (">: [", stdout);
7806       print_vma (tp->start.offset, PREFIX_HEX);
7807       fputc ('-', stdout);
7808       print_vma (tp->end.offset, PREFIX_HEX);
7809       printf ("]\n\t");
7810
7811 #define PF(_m) if (tp->_m) printf (#_m " ");
7812 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7813       PF(Cannot_unwind);
7814       PF(Millicode);
7815       PF(Millicode_save_sr0);
7816       /* PV(Region_description);  */
7817       PF(Entry_SR);
7818       PV(Entry_FR);
7819       PV(Entry_GR);
7820       PF(Args_stored);
7821       PF(Variable_Frame);
7822       PF(Separate_Package_Body);
7823       PF(Frame_Extension_Millicode);
7824       PF(Stack_Overflow_Check);
7825       PF(Two_Instruction_SP_Increment);
7826       PF(Ada_Region);
7827       PF(cxx_info);
7828       PF(cxx_try_catch);
7829       PF(sched_entry_seq);
7830       PF(Save_SP);
7831       PF(Save_RP);
7832       PF(Save_MRP_in_frame);
7833       PF(extn_ptr_defined);
7834       PF(Cleanup_defined);
7835       PF(MPE_XL_interrupt_marker);
7836       PF(HP_UX_interrupt_marker);
7837       PF(Large_frame);
7838       PF(Pseudo_SP_Set);
7839       PV(Total_frame_size);
7840 #undef PF
7841 #undef PV
7842     }
7843
7844   printf ("\n");
7845
7846   free (aux->funtab);
7847
7848   return res;
7849 }
7850
7851 static bfd_boolean
7852 slurp_hppa_unwind_table (Filedata *                  filedata,
7853                          struct hppa_unw_aux_info *  aux,
7854                          Elf_Internal_Shdr *         sec)
7855 {
7856   unsigned long size, unw_ent_size, nentries, nrelas, i;
7857   Elf_Internal_Phdr * seg;
7858   struct hppa_unw_table_entry * tep;
7859   Elf_Internal_Shdr * relsec;
7860   Elf_Internal_Rela * rela;
7861   Elf_Internal_Rela * rp;
7862   unsigned char * table;
7863   unsigned char * tp;
7864   Elf_Internal_Sym * sym;
7865   const char * relname;
7866
7867   /* First, find the starting address of the segment that includes
7868      this section.  */
7869   if (filedata->file_header.e_phnum)
7870     {
7871       if (! get_program_headers (filedata))
7872         return FALSE;
7873
7874       for (seg = filedata->program_headers;
7875            seg < filedata->program_headers + filedata->file_header.e_phnum;
7876            ++seg)
7877         {
7878           if (seg->p_type != PT_LOAD)
7879             continue;
7880
7881           if (sec->sh_addr >= seg->p_vaddr
7882               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7883             {
7884               aux->seg_base = seg->p_vaddr;
7885               break;
7886             }
7887         }
7888     }
7889
7890   /* Second, build the unwind table from the contents of the unwind
7891      section.  */
7892   size = sec->sh_size;
7893   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7894                                       _("unwind table"));
7895   if (!table)
7896     return FALSE;
7897
7898   unw_ent_size = 16;
7899   nentries = size / unw_ent_size;
7900   size = unw_ent_size * nentries;
7901
7902   tep = aux->table = (struct hppa_unw_table_entry *)
7903       xcmalloc (nentries, sizeof (aux->table[0]));
7904
7905   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7906     {
7907       unsigned int tmp1, tmp2;
7908
7909       tep->start.section = SHN_UNDEF;
7910       tep->end.section   = SHN_UNDEF;
7911
7912       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7913       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7914       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7915       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7916
7917       tep->start.offset += aux->seg_base;
7918       tep->end.offset   += aux->seg_base;
7919
7920       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7921       tep->Millicode = (tmp1 >> 30) & 0x1;
7922       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7923       tep->Region_description = (tmp1 >> 27) & 0x3;
7924       tep->reserved1 = (tmp1 >> 26) & 0x1;
7925       tep->Entry_SR = (tmp1 >> 25) & 0x1;
7926       tep->Entry_FR = (tmp1 >> 21) & 0xf;
7927       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7928       tep->Args_stored = (tmp1 >> 15) & 0x1;
7929       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7930       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7931       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7932       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7933       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7934       tep->Ada_Region = (tmp1 >> 9) & 0x1;
7935       tep->cxx_info = (tmp1 >> 8) & 0x1;
7936       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7937       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7938       tep->reserved2 = (tmp1 >> 5) & 0x1;
7939       tep->Save_SP = (tmp1 >> 4) & 0x1;
7940       tep->Save_RP = (tmp1 >> 3) & 0x1;
7941       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7942       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7943       tep->Cleanup_defined = tmp1 & 0x1;
7944
7945       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7946       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7947       tep->Large_frame = (tmp2 >> 29) & 0x1;
7948       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7949       tep->reserved4 = (tmp2 >> 27) & 0x1;
7950       tep->Total_frame_size = tmp2 & 0x7ffffff;
7951     }
7952   free (table);
7953
7954   /* Third, apply any relocations to the unwind table.  */
7955   for (relsec = filedata->section_headers;
7956        relsec < filedata->section_headers + filedata->file_header.e_shnum;
7957        ++relsec)
7958     {
7959       if (relsec->sh_type != SHT_RELA
7960           || relsec->sh_info >= filedata->file_header.e_shnum
7961           || filedata->section_headers + relsec->sh_info != sec)
7962         continue;
7963
7964       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7965                               & rela, & nrelas))
7966         return FALSE;
7967
7968       for (rp = rela; rp < rela + nrelas; ++rp)
7969         {
7970           relname = elf_hppa_reloc_type (get_reloc_type (filedata, rp->r_info));
7971           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7972
7973           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
7974           if (! const_strneq (relname, "R_PARISC_SEGREL"))
7975             {
7976               warn (_("Skipping unexpected relocation type %s\n"), relname);
7977               continue;
7978             }
7979
7980           i = rp->r_offset / unw_ent_size;
7981
7982           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
7983             {
7984             case 0:
7985               aux->table[i].start.section = sym->st_shndx;
7986               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
7987               break;
7988             case 1:
7989               aux->table[i].end.section   = sym->st_shndx;
7990               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
7991               break;
7992             default:
7993               break;
7994             }
7995         }
7996
7997       free (rela);
7998     }
7999
8000   aux->table_len = nentries;
8001
8002   return TRUE;
8003 }
8004
8005 static bfd_boolean
8006 hppa_process_unwind (Filedata * filedata)
8007 {
8008   struct hppa_unw_aux_info aux;
8009   Elf_Internal_Shdr * unwsec = NULL;
8010   Elf_Internal_Shdr * strsec;
8011   Elf_Internal_Shdr * sec;
8012   unsigned long i;
8013   bfd_boolean res = TRUE;
8014
8015   if (filedata->string_table == NULL)
8016     return FALSE;
8017
8018   memset (& aux, 0, sizeof (aux));
8019
8020   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8021     {
8022       if (sec->sh_type == SHT_SYMTAB
8023           && sec->sh_link < filedata->file_header.e_shnum)
8024         {
8025           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
8026
8027           strsec = filedata->section_headers + sec->sh_link;
8028           if (aux.strtab != NULL)
8029             {
8030               error (_("Multiple auxillary string tables encountered\n"));
8031               free (aux.strtab);
8032               res = FALSE;
8033             }
8034           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
8035                                           1, strsec->sh_size,
8036                                           _("string table"));
8037           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8038         }
8039       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8040         unwsec = sec;
8041     }
8042
8043   if (!unwsec)
8044     printf (_("\nThere are no unwind sections in this file.\n"));
8045
8046   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8047     {
8048       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8049         {
8050           unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size + 8);
8051
8052           printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8053                             "contains %lu entry:\n",
8054                             "\nUnwind section '%s' at offset 0x%lx "
8055                             "contains %lu entries:\n",
8056                             num_unwind),
8057                   printable_section_name (filedata, sec),
8058                   (unsigned long) sec->sh_offset,
8059                   num_unwind);
8060
8061           if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8062             res = FALSE;
8063
8064           if (aux.table_len > 0)
8065             {
8066               if (! dump_hppa_unwind (filedata, &aux))
8067                 res = FALSE;
8068             }
8069
8070           if (aux.table)
8071             free ((char *) aux.table);
8072           aux.table = NULL;
8073         }
8074     }
8075
8076   if (aux.symtab)
8077     free (aux.symtab);
8078   if (aux.strtab)
8079     free ((char *) aux.strtab);
8080
8081   return res;
8082 }
8083
8084 struct arm_section
8085 {
8086   unsigned char *      data;            /* The unwind data.  */
8087   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
8088   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
8089   unsigned long        nrelas;          /* The number of relocations.  */
8090   unsigned int         rel_type;        /* REL or RELA ?  */
8091   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
8092 };
8093
8094 struct arm_unw_aux_info
8095 {
8096   Filedata *          filedata;         /* The file containing the unwind sections.  */
8097   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
8098   unsigned long       nsyms;            /* Number of symbols.  */
8099   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
8100   unsigned long       nfuns;            /* Number of these symbols.  */
8101   char *              strtab;           /* The file's string table.  */
8102   unsigned long       strtab_size;      /* Size of string table.  */
8103 };
8104
8105 static const char *
8106 arm_print_vma_and_name (Filedata *                 filedata,
8107                         struct arm_unw_aux_info *  aux,
8108                         bfd_vma                    fn,
8109                         struct absaddr             addr)
8110 {
8111   const char *procname;
8112   bfd_vma sym_offset;
8113
8114   if (addr.section == SHN_UNDEF)
8115     addr.offset = fn;
8116
8117   find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8118                            aux->strtab_size, addr, &procname,
8119                            &sym_offset);
8120
8121   print_vma (fn, PREFIX_HEX);
8122
8123   if (procname)
8124     {
8125       fputs (" <", stdout);
8126       fputs (procname, stdout);
8127
8128       if (sym_offset)
8129         printf ("+0x%lx", (unsigned long) sym_offset);
8130       fputc ('>', stdout);
8131     }
8132
8133   return procname;
8134 }
8135
8136 static void
8137 arm_free_section (struct arm_section *arm_sec)
8138 {
8139   if (arm_sec->data != NULL)
8140     free (arm_sec->data);
8141
8142   if (arm_sec->rela != NULL)
8143     free (arm_sec->rela);
8144 }
8145
8146 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8147       cached section and install SEC instead.
8148    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8149       and return its valued in * WORDP, relocating if necessary.
8150    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8151       relocation's offset in ADDR.
8152    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8153       into the string table of the symbol associated with the reloc.  If no
8154       reloc was applied store -1 there.
8155    5) Return TRUE upon success, FALSE otherwise.  */
8156
8157 static bfd_boolean
8158 get_unwind_section_word (Filedata *                 filedata,
8159                          struct arm_unw_aux_info *  aux,
8160                          struct arm_section *       arm_sec,
8161                          Elf_Internal_Shdr *        sec,
8162                          bfd_vma                    word_offset,
8163                          unsigned int *             wordp,
8164                          struct absaddr *           addr,
8165                          bfd_vma *                  sym_name)
8166 {
8167   Elf_Internal_Rela *rp;
8168   Elf_Internal_Sym *sym;
8169   const char * relname;
8170   unsigned int word;
8171   bfd_boolean wrapped;
8172
8173   if (sec == NULL || arm_sec == NULL)
8174     return FALSE;
8175
8176   addr->section = SHN_UNDEF;
8177   addr->offset = 0;
8178
8179   if (sym_name != NULL)
8180     *sym_name = (bfd_vma) -1;
8181
8182   /* If necessary, update the section cache.  */
8183   if (sec != arm_sec->sec)
8184     {
8185       Elf_Internal_Shdr *relsec;
8186
8187       arm_free_section (arm_sec);
8188
8189       arm_sec->sec = sec;
8190       arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8191                                 sec->sh_size, _("unwind data"));
8192       arm_sec->rela = NULL;
8193       arm_sec->nrelas = 0;
8194
8195       for (relsec = filedata->section_headers;
8196            relsec < filedata->section_headers + filedata->file_header.e_shnum;
8197            ++relsec)
8198         {
8199           if (relsec->sh_info >= filedata->file_header.e_shnum
8200               || filedata->section_headers + relsec->sh_info != sec
8201               /* PR 15745: Check the section type as well.  */
8202               || (relsec->sh_type != SHT_REL
8203                   && relsec->sh_type != SHT_RELA))
8204             continue;
8205
8206           arm_sec->rel_type = relsec->sh_type;
8207           if (relsec->sh_type == SHT_REL)
8208             {
8209               if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8210                                      relsec->sh_size,
8211                                      & arm_sec->rela, & arm_sec->nrelas))
8212                 return FALSE;
8213             }
8214           else /* relsec->sh_type == SHT_RELA */
8215             {
8216               if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8217                                       relsec->sh_size,
8218                                       & arm_sec->rela, & arm_sec->nrelas))
8219                 return FALSE;
8220             }
8221           break;
8222         }
8223
8224       arm_sec->next_rela = arm_sec->rela;
8225     }
8226
8227   /* If there is no unwind data we can do nothing.  */
8228   if (arm_sec->data == NULL)
8229     return FALSE;
8230
8231   /* If the offset is invalid then fail.  */
8232   if (/* PR 21343 *//* PR 18879 */
8233       sec->sh_size < 4
8234       || word_offset > (sec->sh_size - 4)
8235       || ((bfd_signed_vma) word_offset) < 0)
8236     return FALSE;
8237
8238   /* Get the word at the required offset.  */
8239   word = byte_get (arm_sec->data + word_offset, 4);
8240
8241   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
8242   if (arm_sec->rela == NULL)
8243     {
8244       * wordp = word;
8245       return TRUE;
8246     }
8247
8248   /* Look through the relocs to find the one that applies to the provided offset.  */
8249   wrapped = FALSE;
8250   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8251     {
8252       bfd_vma prelval, offset;
8253
8254       if (rp->r_offset > word_offset && !wrapped)
8255         {
8256           rp = arm_sec->rela;
8257           wrapped = TRUE;
8258         }
8259       if (rp->r_offset > word_offset)
8260         break;
8261
8262       if (rp->r_offset & 3)
8263         {
8264           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8265                 (unsigned long) rp->r_offset);
8266           continue;
8267         }
8268
8269       if (rp->r_offset < word_offset)
8270         continue;
8271
8272       /* PR 17531: file: 027-161405-0.004  */
8273       if (aux->symtab == NULL)
8274         continue;
8275
8276       if (arm_sec->rel_type == SHT_REL)
8277         {
8278           offset = word & 0x7fffffff;
8279           if (offset & 0x40000000)
8280             offset |= ~ (bfd_vma) 0x7fffffff;
8281         }
8282       else if (arm_sec->rel_type == SHT_RELA)
8283         offset = rp->r_addend;
8284       else
8285         {
8286           error (_("Unknown section relocation type %d encountered\n"),
8287                  arm_sec->rel_type);
8288           break;
8289         }
8290
8291       /* PR 17531 file: 027-1241568-0.004.  */
8292       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8293         {
8294           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8295                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8296           break;
8297         }
8298
8299       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8300       offset += sym->st_value;
8301       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8302
8303       /* Check that we are processing the expected reloc type.  */
8304       if (filedata->file_header.e_machine == EM_ARM)
8305         {
8306           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8307           if (relname == NULL)
8308             {
8309               warn (_("Skipping unknown ARM relocation type: %d\n"),
8310                     (int) ELF32_R_TYPE (rp->r_info));
8311               continue;
8312             }
8313
8314           if (streq (relname, "R_ARM_NONE"))
8315               continue;
8316
8317           if (! streq (relname, "R_ARM_PREL31"))
8318             {
8319               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8320               continue;
8321             }
8322         }
8323       else if (filedata->file_header.e_machine == EM_TI_C6000)
8324         {
8325           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8326           if (relname == NULL)
8327             {
8328               warn (_("Skipping unknown C6000 relocation type: %d\n"),
8329                     (int) ELF32_R_TYPE (rp->r_info));
8330               continue;
8331             }
8332
8333           if (streq (relname, "R_C6000_NONE"))
8334             continue;
8335
8336           if (! streq (relname, "R_C6000_PREL31"))
8337             {
8338               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8339               continue;
8340             }
8341
8342           prelval >>= 1;
8343         }
8344       else
8345         {
8346           /* This function currently only supports ARM and TI unwinders.  */
8347           warn (_("Only TI and ARM unwinders are currently supported\n"));
8348           break;
8349         }
8350
8351       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8352       addr->section = sym->st_shndx;
8353       addr->offset = offset;
8354
8355       if (sym_name)
8356         * sym_name = sym->st_name;
8357       break;
8358     }
8359
8360   *wordp = word;
8361   arm_sec->next_rela = rp;
8362
8363   return TRUE;
8364 }
8365
8366 static const char *tic6x_unwind_regnames[16] =
8367 {
8368   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8369   "A14", "A13", "A12", "A11", "A10",
8370   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8371 };
8372
8373 static void
8374 decode_tic6x_unwind_regmask (unsigned int mask)
8375 {
8376   int i;
8377
8378   for (i = 12; mask; mask >>= 1, i--)
8379     {
8380       if (mask & 1)
8381         {
8382           fputs (tic6x_unwind_regnames[i], stdout);
8383           if (mask > 1)
8384             fputs (", ", stdout);
8385         }
8386     }
8387 }
8388
8389 #define ADVANCE                                                 \
8390   if (remaining == 0 && more_words)                             \
8391     {                                                           \
8392       data_offset += 4;                                         \
8393       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec,     \
8394                                      data_offset, & word, & addr, NULL))        \
8395         return FALSE;                                           \
8396       remaining = 4;                                            \
8397       more_words--;                                             \
8398     }                                                           \
8399
8400 #define GET_OP(OP)                      \
8401   ADVANCE;                              \
8402   if (remaining)                        \
8403     {                                   \
8404       remaining--;                      \
8405       (OP) = word >> 24;                \
8406       word <<= 8;                       \
8407     }                                   \
8408   else                                  \
8409     {                                   \
8410       printf (_("[Truncated opcode]\n"));       \
8411       return FALSE;                     \
8412     }                                   \
8413   printf ("0x%02x ", OP)
8414
8415 static bfd_boolean
8416 decode_arm_unwind_bytecode (Filedata *                 filedata,
8417                             struct arm_unw_aux_info *  aux,
8418                             unsigned int               word,
8419                             unsigned int               remaining,
8420                             unsigned int               more_words,
8421                             bfd_vma                    data_offset,
8422                             Elf_Internal_Shdr *        data_sec,
8423                             struct arm_section *       data_arm_sec)
8424 {
8425   struct absaddr addr;
8426   bfd_boolean res = TRUE;
8427
8428   /* Decode the unwinding instructions.  */
8429   while (1)
8430     {
8431       unsigned int op, op2;
8432
8433       ADVANCE;
8434       if (remaining == 0)
8435         break;
8436       remaining--;
8437       op = word >> 24;
8438       word <<= 8;
8439
8440       printf ("  0x%02x ", op);
8441
8442       if ((op & 0xc0) == 0x00)
8443         {
8444           int offset = ((op & 0x3f) << 2) + 4;
8445
8446           printf ("     vsp = vsp + %d", offset);
8447         }
8448       else if ((op & 0xc0) == 0x40)
8449         {
8450           int offset = ((op & 0x3f) << 2) + 4;
8451
8452           printf ("     vsp = vsp - %d", offset);
8453         }
8454       else if ((op & 0xf0) == 0x80)
8455         {
8456           GET_OP (op2);
8457           if (op == 0x80 && op2 == 0)
8458             printf (_("Refuse to unwind"));
8459           else
8460             {
8461               unsigned int mask = ((op & 0x0f) << 8) | op2;
8462               bfd_boolean first = TRUE;
8463               int i;
8464
8465               printf ("pop {");
8466               for (i = 0; i < 12; i++)
8467                 if (mask & (1 << i))
8468                   {
8469                     if (first)
8470                       first = FALSE;
8471                     else
8472                       printf (", ");
8473                     printf ("r%d", 4 + i);
8474                   }
8475               printf ("}");
8476             }
8477         }
8478       else if ((op & 0xf0) == 0x90)
8479         {
8480           if (op == 0x9d || op == 0x9f)
8481             printf (_("     [Reserved]"));
8482           else
8483             printf ("     vsp = r%d", op & 0x0f);
8484         }
8485       else if ((op & 0xf0) == 0xa0)
8486         {
8487           int end = 4 + (op & 0x07);
8488           bfd_boolean first = TRUE;
8489           int i;
8490
8491           printf ("     pop {");
8492           for (i = 4; i <= end; i++)
8493             {
8494               if (first)
8495                 first = FALSE;
8496               else
8497                 printf (", ");
8498               printf ("r%d", i);
8499             }
8500           if (op & 0x08)
8501             {
8502               if (!first)
8503                 printf (", ");
8504               printf ("r14");
8505             }
8506           printf ("}");
8507         }
8508       else if (op == 0xb0)
8509         printf (_("     finish"));
8510       else if (op == 0xb1)
8511         {
8512           GET_OP (op2);
8513           if (op2 == 0 || (op2 & 0xf0) != 0)
8514             printf (_("[Spare]"));
8515           else
8516             {
8517               unsigned int mask = op2 & 0x0f;
8518               bfd_boolean first = TRUE;
8519               int i;
8520
8521               printf ("pop {");
8522               for (i = 0; i < 12; i++)
8523                 if (mask & (1 << i))
8524                   {
8525                     if (first)
8526                       first = FALSE;
8527                     else
8528                       printf (", ");
8529                     printf ("r%d", i);
8530                   }
8531               printf ("}");
8532             }
8533         }
8534       else if (op == 0xb2)
8535         {
8536           unsigned char buf[9];
8537           unsigned int i, len;
8538           unsigned long offset;
8539
8540           for (i = 0; i < sizeof (buf); i++)
8541             {
8542               GET_OP (buf[i]);
8543               if ((buf[i] & 0x80) == 0)
8544                 break;
8545             }
8546           if (i == sizeof (buf))
8547             {
8548               error (_("corrupt change to vsp"));
8549               res = FALSE;
8550             }
8551           else
8552             {
8553               offset = read_uleb128 (buf, &len, buf + i + 1);
8554               assert (len == i + 1);
8555               offset = offset * 4 + 0x204;
8556               printf ("vsp = vsp + %ld", offset);
8557             }
8558         }
8559       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8560         {
8561           unsigned int first, last;
8562
8563           GET_OP (op2);
8564           first = op2 >> 4;
8565           last = op2 & 0x0f;
8566           if (op == 0xc8)
8567             first = first + 16;
8568           printf ("pop {D%d", first);
8569           if (last)
8570             printf ("-D%d", first + last);
8571           printf ("}");
8572         }
8573       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8574         {
8575           unsigned int count = op & 0x07;
8576
8577           printf ("pop {D8");
8578           if (count)
8579             printf ("-D%d", 8 + count);
8580           printf ("}");
8581         }
8582       else if (op >= 0xc0 && op <= 0xc5)
8583         {
8584           unsigned int count = op & 0x07;
8585
8586           printf ("     pop {wR10");
8587           if (count)
8588             printf ("-wR%d", 10 + count);
8589           printf ("}");
8590         }
8591       else if (op == 0xc6)
8592         {
8593           unsigned int first, last;
8594
8595           GET_OP (op2);
8596           first = op2 >> 4;
8597           last = op2 & 0x0f;
8598           printf ("pop {wR%d", first);
8599           if (last)
8600             printf ("-wR%d", first + last);
8601           printf ("}");
8602         }
8603       else if (op == 0xc7)
8604         {
8605           GET_OP (op2);
8606           if (op2 == 0 || (op2 & 0xf0) != 0)
8607             printf (_("[Spare]"));
8608           else
8609             {
8610               unsigned int mask = op2 & 0x0f;
8611               bfd_boolean first = TRUE;
8612               int i;
8613
8614               printf ("pop {");
8615               for (i = 0; i < 4; i++)
8616                 if (mask & (1 << i))
8617                   {
8618                     if (first)
8619                       first = FALSE;
8620                     else
8621                       printf (", ");
8622                     printf ("wCGR%d", i);
8623                   }
8624               printf ("}");
8625             }
8626         }
8627       else
8628         {
8629           printf (_("     [unsupported opcode]"));
8630           res = FALSE;
8631         }
8632
8633       printf ("\n");
8634     }
8635
8636   return res;
8637 }
8638
8639 static bfd_boolean
8640 decode_tic6x_unwind_bytecode (Filedata *                 filedata,
8641                               struct arm_unw_aux_info *  aux,
8642                               unsigned int               word,
8643                               unsigned int               remaining,
8644                               unsigned int               more_words,
8645                               bfd_vma                    data_offset,
8646                               Elf_Internal_Shdr *        data_sec,
8647                               struct arm_section *       data_arm_sec)
8648 {
8649   struct absaddr addr;
8650
8651   /* Decode the unwinding instructions.  */
8652   while (1)
8653     {
8654       unsigned int op, op2;
8655
8656       ADVANCE;
8657       if (remaining == 0)
8658         break;
8659       remaining--;
8660       op = word >> 24;
8661       word <<= 8;
8662
8663       printf ("  0x%02x ", op);
8664
8665       if ((op & 0xc0) == 0x00)
8666         {
8667           int offset = ((op & 0x3f) << 3) + 8;
8668           printf ("     sp = sp + %d", offset);
8669         }
8670       else if ((op & 0xc0) == 0x80)
8671         {
8672           GET_OP (op2);
8673           if (op == 0x80 && op2 == 0)
8674             printf (_("Refuse to unwind"));
8675           else
8676             {
8677               unsigned int mask = ((op & 0x1f) << 8) | op2;
8678               if (op & 0x20)
8679                 printf ("pop compact {");
8680               else
8681                 printf ("pop {");
8682
8683               decode_tic6x_unwind_regmask (mask);
8684               printf("}");
8685             }
8686         }
8687       else if ((op & 0xf0) == 0xc0)
8688         {
8689           unsigned int reg;
8690           unsigned int nregs;
8691           unsigned int i;
8692           const char *name;
8693           struct
8694           {
8695             unsigned int offset;
8696             unsigned int reg;
8697           } regpos[16];
8698
8699           /* Scan entire instruction first so that GET_OP output is not
8700              interleaved with disassembly.  */
8701           nregs = 0;
8702           for (i = 0; nregs < (op & 0xf); i++)
8703             {
8704               GET_OP (op2);
8705               reg = op2 >> 4;
8706               if (reg != 0xf)
8707                 {
8708                   regpos[nregs].offset = i * 2;
8709                   regpos[nregs].reg = reg;
8710                   nregs++;
8711                 }
8712
8713               reg = op2 & 0xf;
8714               if (reg != 0xf)
8715                 {
8716                   regpos[nregs].offset = i * 2 + 1;
8717                   regpos[nregs].reg = reg;
8718                   nregs++;
8719                 }
8720             }
8721
8722           printf (_("pop frame {"));
8723           reg = nregs - 1;
8724           for (i = i * 2; i > 0; i--)
8725             {
8726               if (regpos[reg].offset == i - 1)
8727                 {
8728                   name = tic6x_unwind_regnames[regpos[reg].reg];
8729                   if (reg > 0)
8730                     reg--;
8731                 }
8732               else
8733                 name = _("[pad]");
8734
8735               fputs (name, stdout);
8736               if (i > 1)
8737                 printf (", ");
8738             }
8739
8740           printf ("}");
8741         }
8742       else if (op == 0xd0)
8743         printf ("     MOV FP, SP");
8744       else if (op == 0xd1)
8745         printf ("     __c6xabi_pop_rts");
8746       else if (op == 0xd2)
8747         {
8748           unsigned char buf[9];
8749           unsigned int i, len;
8750           unsigned long offset;
8751
8752           for (i = 0; i < sizeof (buf); i++)
8753             {
8754               GET_OP (buf[i]);
8755               if ((buf[i] & 0x80) == 0)
8756                 break;
8757             }
8758           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8759           if (i == sizeof (buf))
8760             {
8761               warn (_("Corrupt stack pointer adjustment detected\n"));
8762               return FALSE;
8763             }
8764
8765           offset = read_uleb128 (buf, &len, buf + i + 1);
8766           assert (len == i + 1);
8767           offset = offset * 8 + 0x408;
8768           printf (_("sp = sp + %ld"), offset);
8769         }
8770       else if ((op & 0xf0) == 0xe0)
8771         {
8772           if ((op & 0x0f) == 7)
8773             printf ("     RETURN");
8774           else
8775             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8776         }
8777       else
8778         {
8779           printf (_("     [unsupported opcode]"));
8780         }
8781       putchar ('\n');
8782     }
8783
8784   return TRUE;
8785 }
8786
8787 static bfd_vma
8788 arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
8789 {
8790   bfd_vma offset;
8791
8792   offset = word & 0x7fffffff;
8793   if (offset & 0x40000000)
8794     offset |= ~ (bfd_vma) 0x7fffffff;
8795
8796   if (filedata->file_header.e_machine == EM_TI_C6000)
8797     offset <<= 1;
8798
8799   return offset + where;
8800 }
8801
8802 static bfd_boolean
8803 decode_arm_unwind (Filedata *                 filedata,
8804                    struct arm_unw_aux_info *  aux,
8805                    unsigned int               word,
8806                    unsigned int               remaining,
8807                    bfd_vma                    data_offset,
8808                    Elf_Internal_Shdr *        data_sec,
8809                    struct arm_section *       data_arm_sec)
8810 {
8811   int per_index;
8812   unsigned int more_words = 0;
8813   struct absaddr addr;
8814   bfd_vma sym_name = (bfd_vma) -1;
8815   bfd_boolean res = TRUE;
8816
8817   if (remaining == 0)
8818     {
8819       /* Fetch the first word.
8820          Note - when decoding an object file the address extracted
8821          here will always be 0.  So we also pass in the sym_name
8822          parameter so that we can find the symbol associated with
8823          the personality routine.  */
8824       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
8825                                      & word, & addr, & sym_name))
8826         return FALSE;
8827
8828       remaining = 4;
8829     }
8830
8831   if ((word & 0x80000000) == 0)
8832     {
8833       /* Expand prel31 for personality routine.  */
8834       bfd_vma fn;
8835       const char *procname;
8836
8837       fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
8838       printf (_("  Personality routine: "));
8839       if (fn == 0
8840           && addr.section == SHN_UNDEF && addr.offset == 0
8841           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8842         {
8843           procname = aux->strtab + sym_name;
8844           print_vma (fn, PREFIX_HEX);
8845           if (procname)
8846             {
8847               fputs (" <", stdout);
8848               fputs (procname, stdout);
8849               fputc ('>', stdout);
8850             }
8851         }
8852       else
8853         procname = arm_print_vma_and_name (filedata, aux, fn, addr);
8854       fputc ('\n', stdout);
8855
8856       /* The GCC personality routines use the standard compact
8857          encoding, starting with one byte giving the number of
8858          words.  */
8859       if (procname != NULL
8860           && (const_strneq (procname, "__gcc_personality_v0")
8861               || const_strneq (procname, "__gxx_personality_v0")
8862               || const_strneq (procname, "__gcj_personality_v0")
8863               || const_strneq (procname, "__gnu_objc_personality_v0")))
8864         {
8865           remaining = 0;
8866           more_words = 1;
8867           ADVANCE;
8868           if (!remaining)
8869             {
8870               printf (_("  [Truncated data]\n"));
8871               return FALSE;
8872             }
8873           more_words = word >> 24;
8874           word <<= 8;
8875           remaining--;
8876           per_index = -1;
8877         }
8878       else
8879         return TRUE;
8880     }
8881   else
8882     {
8883       /* ARM EHABI Section 6.3:
8884
8885          An exception-handling table entry for the compact model looks like:
8886
8887            31 30-28 27-24 23-0
8888            -- ----- ----- ----
8889             1   0   index Data for personalityRoutine[index]    */
8890
8891       if (filedata->file_header.e_machine == EM_ARM
8892           && (word & 0x70000000))
8893         {
8894           warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8895           res = FALSE;
8896         }
8897
8898       per_index = (word >> 24) & 0x7f;
8899       printf (_("  Compact model index: %d\n"), per_index);
8900       if (per_index == 0)
8901         {
8902           more_words = 0;
8903           word <<= 8;
8904           remaining--;
8905         }
8906       else if (per_index < 3)
8907         {
8908           more_words = (word >> 16) & 0xff;
8909           word <<= 16;
8910           remaining -= 2;
8911         }
8912     }
8913
8914   switch (filedata->file_header.e_machine)
8915     {
8916     case EM_ARM:
8917       if (per_index < 3)
8918         {
8919           if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
8920                                             data_offset, data_sec, data_arm_sec))
8921             res = FALSE;
8922         }
8923       else
8924         {
8925           warn (_("Unknown ARM compact model index encountered\n"));
8926           printf (_("  [reserved]\n"));
8927           res = FALSE;
8928         }
8929       break;
8930
8931     case EM_TI_C6000:
8932       if (per_index < 3)
8933         {
8934           if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
8935                                               data_offset, data_sec, data_arm_sec))
8936             res = FALSE;
8937         }
8938       else if (per_index < 5)
8939         {
8940           if (((word >> 17) & 0x7f) == 0x7f)
8941             printf (_("  Restore stack from frame pointer\n"));
8942           else
8943             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
8944           printf (_("  Registers restored: "));
8945           if (per_index == 4)
8946             printf (" (compact) ");
8947           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8948           putchar ('\n');
8949           printf (_("  Return register: %s\n"),
8950                   tic6x_unwind_regnames[word & 0xf]);
8951         }
8952       else
8953         printf (_("  [reserved (%d)]\n"), per_index);
8954       break;
8955
8956     default:
8957       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8958              filedata->file_header.e_machine);
8959       res = FALSE;
8960     }
8961
8962   /* Decode the descriptors.  Not implemented.  */
8963
8964   return res;
8965 }
8966
8967 static bfd_boolean
8968 dump_arm_unwind (Filedata *                 filedata,
8969                  struct arm_unw_aux_info *  aux,
8970                  Elf_Internal_Shdr *        exidx_sec)
8971 {
8972   struct arm_section exidx_arm_sec, extab_arm_sec;
8973   unsigned int i, exidx_len;
8974   unsigned long j, nfuns;
8975   bfd_boolean res = TRUE;
8976
8977   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8978   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8979   exidx_len = exidx_sec->sh_size / 8;
8980
8981   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8982   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8983     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8984       aux->funtab[nfuns++] = aux->symtab[j];
8985   aux->nfuns = nfuns;
8986   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8987
8988   for (i = 0; i < exidx_len; i++)
8989     {
8990       unsigned int exidx_fn, exidx_entry;
8991       struct absaddr fn_addr, entry_addr;
8992       bfd_vma fn;
8993
8994       fputc ('\n', stdout);
8995
8996       if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
8997                                      8 * i, & exidx_fn, & fn_addr, NULL)
8998           || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
8999                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
9000         {
9001           free (aux->funtab);
9002           arm_free_section (& exidx_arm_sec);
9003           arm_free_section (& extab_arm_sec);
9004           return FALSE;
9005         }
9006
9007       /* ARM EHABI, Section 5:
9008          An index table entry consists of 2 words.
9009          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
9010       if (exidx_fn & 0x80000000)
9011         {
9012           warn (_("corrupt index table entry: %x\n"), exidx_fn);
9013           res = FALSE;
9014         }
9015
9016       fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9017
9018       arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9019       fputs (": ", stdout);
9020
9021       if (exidx_entry == 1)
9022         {
9023           print_vma (exidx_entry, PREFIX_HEX);
9024           fputs (" [cantunwind]\n", stdout);
9025         }
9026       else if (exidx_entry & 0x80000000)
9027         {
9028           print_vma (exidx_entry, PREFIX_HEX);
9029           fputc ('\n', stdout);
9030           decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9031         }
9032       else
9033         {
9034           bfd_vma table, table_offset = 0;
9035           Elf_Internal_Shdr *table_sec;
9036
9037           fputs ("@", stdout);
9038           table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9039           print_vma (table, PREFIX_HEX);
9040           printf ("\n");
9041
9042           /* Locate the matching .ARM.extab.  */
9043           if (entry_addr.section != SHN_UNDEF
9044               && entry_addr.section < filedata->file_header.e_shnum)
9045             {
9046               table_sec = filedata->section_headers + entry_addr.section;
9047               table_offset = entry_addr.offset;
9048               /* PR 18879 */
9049               if (table_offset > table_sec->sh_size
9050                   || ((bfd_signed_vma) table_offset) < 0)
9051                 {
9052                   warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9053                         (unsigned long) table_offset,
9054                         printable_section_name (filedata, table_sec));
9055                   res = FALSE;
9056                   continue;
9057                 }
9058             }
9059           else
9060             {
9061               table_sec = find_section_by_address (filedata, table);
9062               if (table_sec != NULL)
9063                 table_offset = table - table_sec->sh_addr;
9064             }
9065
9066           if (table_sec == NULL)
9067             {
9068               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9069                     (unsigned long) table);
9070               res = FALSE;
9071               continue;
9072             }
9073
9074           if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9075                                    &extab_arm_sec))
9076             res = FALSE;
9077         }
9078     }
9079
9080   printf ("\n");
9081
9082   free (aux->funtab);
9083   arm_free_section (&exidx_arm_sec);
9084   arm_free_section (&extab_arm_sec);
9085
9086   return res;
9087 }
9088
9089 /* Used for both ARM and C6X unwinding tables.  */
9090
9091 static bfd_boolean
9092 arm_process_unwind (Filedata * filedata)
9093 {
9094   struct arm_unw_aux_info aux;
9095   Elf_Internal_Shdr *unwsec = NULL;
9096   Elf_Internal_Shdr *strsec;
9097   Elf_Internal_Shdr *sec;
9098   unsigned long i;
9099   unsigned int sec_type;
9100   bfd_boolean res = TRUE;
9101
9102   switch (filedata->file_header.e_machine)
9103     {
9104     case EM_ARM:
9105       sec_type = SHT_ARM_EXIDX;
9106       break;
9107
9108     case EM_TI_C6000:
9109       sec_type = SHT_C6000_UNWIND;
9110       break;
9111
9112     default:
9113       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9114              filedata->file_header.e_machine);
9115       return FALSE;
9116     }
9117
9118   if (filedata->string_table == NULL)
9119     return FALSE;
9120
9121   memset (& aux, 0, sizeof (aux));
9122   aux.filedata = filedata;
9123
9124   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9125     {
9126       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < filedata->file_header.e_shnum)
9127         {
9128           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
9129
9130           strsec = filedata->section_headers + sec->sh_link;
9131
9132           /* PR binutils/17531 file: 011-12666-0.004.  */
9133           if (aux.strtab != NULL)
9134             {
9135               error (_("Multiple string tables found in file.\n"));
9136               free (aux.strtab);
9137               res = FALSE;
9138             }
9139           aux.strtab = get_data (NULL, filedata, strsec->sh_offset,
9140                                  1, strsec->sh_size, _("string table"));
9141           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9142         }
9143       else if (sec->sh_type == sec_type)
9144         unwsec = sec;
9145     }
9146
9147   if (unwsec == NULL)
9148     printf (_("\nThere are no unwind sections in this file.\n"));
9149   else
9150     for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9151       {
9152         if (sec->sh_type == sec_type)
9153           {
9154             unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9155             printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9156                               "contains %lu entry:\n",
9157                               "\nUnwind section '%s' at offset 0x%lx "
9158                               "contains %lu entries:\n",
9159                               num_unwind),
9160                     printable_section_name (filedata, sec),
9161                     (unsigned long) sec->sh_offset,
9162                     num_unwind);
9163
9164             if (! dump_arm_unwind (filedata, &aux, sec))
9165               res = FALSE;
9166           }
9167       }
9168
9169   if (aux.symtab)
9170     free (aux.symtab);
9171   if (aux.strtab)
9172     free ((char *) aux.strtab);
9173
9174   return res;
9175 }
9176
9177 static bfd_boolean
9178 process_unwind (Filedata * filedata)
9179 {
9180   struct unwind_handler
9181   {
9182     unsigned int machtype;
9183     bfd_boolean (* handler)(Filedata *);
9184   } handlers[] =
9185   {
9186     { EM_ARM, arm_process_unwind },
9187     { EM_IA_64, ia64_process_unwind },
9188     { EM_PARISC, hppa_process_unwind },
9189     { EM_TI_C6000, arm_process_unwind },
9190     { 0, NULL }
9191   };
9192   int i;
9193
9194   if (!do_unwind)
9195     return TRUE;
9196
9197   for (i = 0; handlers[i].handler != NULL; i++)
9198     if (filedata->file_header.e_machine == handlers[i].machtype)
9199       return handlers[i].handler (filedata);
9200
9201   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9202           get_machine_name (filedata->file_header.e_machine));
9203   return TRUE;
9204 }
9205
9206 static void
9207 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9208 {
9209   switch (entry->d_tag)
9210     {
9211     case DT_MIPS_FLAGS:
9212       if (entry->d_un.d_val == 0)
9213         printf (_("NONE"));
9214       else
9215         {
9216           static const char * opts[] =
9217           {
9218             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9219             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9220             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9221             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9222             "RLD_ORDER_SAFE"
9223           };
9224           unsigned int cnt;
9225           bfd_boolean first = TRUE;
9226
9227           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9228             if (entry->d_un.d_val & (1 << cnt))
9229               {
9230                 printf ("%s%s", first ? "" : " ", opts[cnt]);
9231                 first = FALSE;
9232               }
9233         }
9234       break;
9235
9236     case DT_MIPS_IVERSION:
9237       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9238         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9239       else
9240         {
9241           char buf[40];
9242           sprintf_vma (buf, entry->d_un.d_ptr);
9243           /* Note: coded this way so that there is a single string for translation.  */
9244           printf (_("<corrupt: %s>"), buf);
9245         }
9246       break;
9247
9248     case DT_MIPS_TIME_STAMP:
9249       {
9250         char timebuf[128];
9251         struct tm * tmp;
9252         time_t atime = entry->d_un.d_val;
9253
9254         tmp = gmtime (&atime);
9255         /* PR 17531: file: 6accc532.  */
9256         if (tmp == NULL)
9257           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9258         else
9259           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9260                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9261                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9262         printf (_("Time Stamp: %s"), timebuf);
9263       }
9264       break;
9265
9266     case DT_MIPS_RLD_VERSION:
9267     case DT_MIPS_LOCAL_GOTNO:
9268     case DT_MIPS_CONFLICTNO:
9269     case DT_MIPS_LIBLISTNO:
9270     case DT_MIPS_SYMTABNO:
9271     case DT_MIPS_UNREFEXTNO:
9272     case DT_MIPS_HIPAGENO:
9273     case DT_MIPS_DELTA_CLASS_NO:
9274     case DT_MIPS_DELTA_INSTANCE_NO:
9275     case DT_MIPS_DELTA_RELOC_NO:
9276     case DT_MIPS_DELTA_SYM_NO:
9277     case DT_MIPS_DELTA_CLASSSYM_NO:
9278     case DT_MIPS_COMPACT_SIZE:
9279       print_vma (entry->d_un.d_val, DEC);
9280       break;
9281
9282     default:
9283       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9284     }
9285     putchar ('\n');
9286 }
9287
9288 static void
9289 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9290 {
9291   switch (entry->d_tag)
9292     {
9293     case DT_HP_DLD_FLAGS:
9294       {
9295         static struct
9296         {
9297           long int bit;
9298           const char * str;
9299         }
9300         flags[] =
9301         {
9302           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9303           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9304           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9305           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9306           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9307           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9308           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9309           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9310           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9311           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9312           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9313           { DT_HP_GST, "HP_GST" },
9314           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9315           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9316           { DT_HP_NODELETE, "HP_NODELETE" },
9317           { DT_HP_GROUP, "HP_GROUP" },
9318           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9319         };
9320         bfd_boolean first = TRUE;
9321         size_t cnt;
9322         bfd_vma val = entry->d_un.d_val;
9323
9324         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9325           if (val & flags[cnt].bit)
9326             {
9327               if (! first)
9328                 putchar (' ');
9329               fputs (flags[cnt].str, stdout);
9330               first = FALSE;
9331               val ^= flags[cnt].bit;
9332             }
9333
9334         if (val != 0 || first)
9335           {
9336             if (! first)
9337               putchar (' ');
9338             print_vma (val, HEX);
9339           }
9340       }
9341       break;
9342
9343     default:
9344       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9345       break;
9346     }
9347   putchar ('\n');
9348 }
9349
9350 #ifdef BFD64
9351
9352 /* VMS vs Unix time offset and factor.  */
9353
9354 #define VMS_EPOCH_OFFSET 35067168000000000LL
9355 #define VMS_GRANULARITY_FACTOR 10000000
9356
9357 /* Display a VMS time in a human readable format.  */
9358
9359 static void
9360 print_vms_time (bfd_int64_t vmstime)
9361 {
9362   struct tm *tm;
9363   time_t unxtime;
9364
9365   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9366   tm = gmtime (&unxtime);
9367   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9368           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9369           tm->tm_hour, tm->tm_min, tm->tm_sec);
9370 }
9371 #endif /* BFD64 */
9372
9373 static void
9374 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9375 {
9376   switch (entry->d_tag)
9377     {
9378     case DT_IA_64_PLT_RESERVE:
9379       /* First 3 slots reserved.  */
9380       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9381       printf (" -- ");
9382       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9383       break;
9384
9385     case DT_IA_64_VMS_LINKTIME:
9386 #ifdef BFD64
9387       print_vms_time (entry->d_un.d_val);
9388 #endif
9389       break;
9390
9391     case DT_IA_64_VMS_LNKFLAGS:
9392       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9393       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9394         printf (" CALL_DEBUG");
9395       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9396         printf (" NOP0BUFS");
9397       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9398         printf (" P0IMAGE");
9399       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9400         printf (" MKTHREADS");
9401       if (entry->d_un.d_val & VMS_LF_UPCALLS)
9402         printf (" UPCALLS");
9403       if (entry->d_un.d_val & VMS_LF_IMGSTA)
9404         printf (" IMGSTA");
9405       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9406         printf (" INITIALIZE");
9407       if (entry->d_un.d_val & VMS_LF_MAIN)
9408         printf (" MAIN");
9409       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9410         printf (" EXE_INIT");
9411       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9412         printf (" TBK_IN_IMG");
9413       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9414         printf (" DBG_IN_IMG");
9415       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9416         printf (" TBK_IN_DSF");
9417       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9418         printf (" DBG_IN_DSF");
9419       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9420         printf (" SIGNATURES");
9421       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9422         printf (" REL_SEG_OFF");
9423       break;
9424
9425     default:
9426       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9427       break;
9428     }
9429   putchar ('\n');
9430 }
9431
9432 static bfd_boolean
9433 get_32bit_dynamic_section (Filedata * filedata)
9434 {
9435   Elf32_External_Dyn * edyn;
9436   Elf32_External_Dyn * ext;
9437   Elf_Internal_Dyn * entry;
9438
9439   edyn = (Elf32_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9440                                           dynamic_size, _("dynamic section"));
9441   if (!edyn)
9442     return FALSE;
9443
9444   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9445      might not have the luxury of section headers.  Look for the DT_NULL
9446      terminator to determine the number of entries.  */
9447   for (ext = edyn, dynamic_nent = 0;
9448        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9449        ext++)
9450     {
9451       dynamic_nent++;
9452       if (BYTE_GET (ext->d_tag) == DT_NULL)
9453         break;
9454     }
9455
9456   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9457                                                   sizeof (* entry));
9458   if (dynamic_section == NULL)
9459     {
9460       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9461              (unsigned long) dynamic_nent);
9462       free (edyn);
9463       return FALSE;
9464     }
9465
9466   for (ext = edyn, entry = dynamic_section;
9467        entry < dynamic_section + dynamic_nent;
9468        ext++, entry++)
9469     {
9470       entry->d_tag      = BYTE_GET (ext->d_tag);
9471       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9472     }
9473
9474   free (edyn);
9475
9476   return TRUE;
9477 }
9478
9479 static bfd_boolean
9480 get_64bit_dynamic_section (Filedata * filedata)
9481 {
9482   Elf64_External_Dyn * edyn;
9483   Elf64_External_Dyn * ext;
9484   Elf_Internal_Dyn * entry;
9485
9486   /* Read in the data.  */
9487   edyn = (Elf64_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9488                                           dynamic_size, _("dynamic section"));
9489   if (!edyn)
9490     return FALSE;
9491
9492   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9493      might not have the luxury of section headers.  Look for the DT_NULL
9494      terminator to determine the number of entries.  */
9495   for (ext = edyn, dynamic_nent = 0;
9496        /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer.  */
9497        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9498        ext++)
9499     {
9500       dynamic_nent++;
9501       if (BYTE_GET (ext->d_tag) == DT_NULL)
9502         break;
9503     }
9504
9505   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9506                                                   sizeof (* entry));
9507   if (dynamic_section == NULL)
9508     {
9509       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9510              (unsigned long) dynamic_nent);
9511       free (edyn);
9512       return FALSE;
9513     }
9514
9515   /* Convert from external to internal formats.  */
9516   for (ext = edyn, entry = dynamic_section;
9517        entry < dynamic_section + dynamic_nent;
9518        ext++, entry++)
9519     {
9520       entry->d_tag      = BYTE_GET (ext->d_tag);
9521       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9522     }
9523
9524   free (edyn);
9525
9526   return TRUE;
9527 }
9528
9529 static void
9530 print_dynamic_flags (bfd_vma flags)
9531 {
9532   bfd_boolean first = TRUE;
9533
9534   while (flags)
9535     {
9536       bfd_vma flag;
9537
9538       flag = flags & - flags;
9539       flags &= ~ flag;
9540
9541       if (first)
9542         first = FALSE;
9543       else
9544         putc (' ', stdout);
9545
9546       switch (flag)
9547         {
9548         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
9549         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
9550         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
9551         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
9552         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
9553         default:                fputs (_("unknown"), stdout); break;
9554         }
9555     }
9556   puts ("");
9557 }
9558
9559 /* Parse and display the contents of the dynamic section.  */
9560
9561 static bfd_boolean
9562 process_dynamic_section (Filedata * filedata)
9563 {
9564   Elf_Internal_Dyn * entry;
9565
9566   if (dynamic_size == 0)
9567     {
9568       if (do_dynamic)
9569         printf (_("\nThere is no dynamic section in this file.\n"));
9570
9571       return TRUE;
9572     }
9573
9574   if (is_32bit_elf)
9575     {
9576       if (! get_32bit_dynamic_section (filedata))
9577         return FALSE;
9578     }
9579   else
9580     {
9581       if (! get_64bit_dynamic_section (filedata))
9582         return FALSE;
9583     }
9584
9585   /* Find the appropriate symbol table.  */
9586   if (dynamic_symbols == NULL)
9587     {
9588       for (entry = dynamic_section;
9589            entry < dynamic_section + dynamic_nent;
9590            ++entry)
9591         {
9592           Elf_Internal_Shdr section;
9593
9594           if (entry->d_tag != DT_SYMTAB)
9595             continue;
9596
9597           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9598
9599           /* Since we do not know how big the symbol table is,
9600              we default to reading in the entire file (!) and
9601              processing that.  This is overkill, I know, but it
9602              should work.  */
9603           section.sh_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9604           if ((bfd_size_type) section.sh_offset > filedata->file_size)
9605             {
9606               /* See PR 21379 for a reproducer.  */
9607               error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9608               return FALSE;
9609             }
9610
9611           if (archive_file_offset != 0)
9612             section.sh_size = archive_file_size - section.sh_offset;
9613           else
9614             section.sh_size = filedata->file_size - section.sh_offset;
9615
9616           if (is_32bit_elf)
9617             section.sh_entsize = sizeof (Elf32_External_Sym);
9618           else
9619             section.sh_entsize = sizeof (Elf64_External_Sym);
9620           section.sh_name = filedata->string_table_length;
9621
9622           dynamic_symbols = GET_ELF_SYMBOLS (filedata, &section, & num_dynamic_syms);
9623           if (num_dynamic_syms < 1)
9624             {
9625               error (_("Unable to determine the number of symbols to load\n"));
9626               continue;
9627             }
9628         }
9629     }
9630
9631   /* Similarly find a string table.  */
9632   if (dynamic_strings == NULL)
9633     {
9634       for (entry = dynamic_section;
9635            entry < dynamic_section + dynamic_nent;
9636            ++entry)
9637         {
9638           unsigned long offset;
9639           long str_tab_len;
9640
9641           if (entry->d_tag != DT_STRTAB)
9642             continue;
9643
9644           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9645
9646           /* Since we do not know how big the string table is,
9647              we default to reading in the entire file (!) and
9648              processing that.  This is overkill, I know, but it
9649              should work.  */
9650
9651           offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9652
9653           if (archive_file_offset != 0)
9654             str_tab_len = archive_file_size - offset;
9655           else
9656             str_tab_len = filedata->file_size;
9657
9658           if (str_tab_len < 1)
9659             {
9660               error
9661                 (_("Unable to determine the length of the dynamic string table\n"));
9662               continue;
9663             }
9664
9665           dynamic_strings = (char *) get_data (NULL, filedata, offset, 1,
9666                                                str_tab_len,
9667                                                _("dynamic string table"));
9668           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9669           break;
9670         }
9671     }
9672
9673   /* And find the syminfo section if available.  */
9674   if (dynamic_syminfo == NULL)
9675     {
9676       unsigned long syminsz = 0;
9677
9678       for (entry = dynamic_section;
9679            entry < dynamic_section + dynamic_nent;
9680            ++entry)
9681         {
9682           if (entry->d_tag == DT_SYMINENT)
9683             {
9684               /* Note: these braces are necessary to avoid a syntax
9685                  error from the SunOS4 C compiler.  */
9686               /* PR binutils/17531: A corrupt file can trigger this test.
9687                  So do not use an assert, instead generate an error message.  */
9688               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9689                 error (_("Bad value (%d) for SYMINENT entry\n"),
9690                        (int) entry->d_un.d_val);
9691             }
9692           else if (entry->d_tag == DT_SYMINSZ)
9693             syminsz = entry->d_un.d_val;
9694           else if (entry->d_tag == DT_SYMINFO)
9695             dynamic_syminfo_offset = offset_from_vma (filedata, entry->d_un.d_val,
9696                                                       syminsz);
9697         }
9698
9699       if (dynamic_syminfo_offset != 0 && syminsz != 0)
9700         {
9701           Elf_External_Syminfo * extsyminfo;
9702           Elf_External_Syminfo * extsym;
9703           Elf_Internal_Syminfo * syminfo;
9704
9705           /* There is a syminfo section.  Read the data.  */
9706           extsyminfo = (Elf_External_Syminfo *)
9707               get_data (NULL, filedata, dynamic_syminfo_offset, 1, syminsz,
9708                         _("symbol information"));
9709           if (!extsyminfo)
9710             return FALSE;
9711
9712           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9713           if (dynamic_syminfo == NULL)
9714             {
9715               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9716                      (unsigned long) syminsz);
9717               return FALSE;
9718             }
9719
9720           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9721           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9722                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9723                ++syminfo, ++extsym)
9724             {
9725               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9726               syminfo->si_flags = BYTE_GET (extsym->si_flags);
9727             }
9728
9729           free (extsyminfo);
9730         }
9731     }
9732
9733   if (do_dynamic && dynamic_addr)
9734     printf (ngettext ("\nDynamic section at offset 0x%lx "
9735                       "contains %lu entry:\n",
9736                       "\nDynamic section at offset 0x%lx "
9737                       "contains %lu entries:\n",
9738                       dynamic_nent),
9739             dynamic_addr, (unsigned long) dynamic_nent);
9740   if (do_dynamic)
9741     printf (_("  Tag        Type                         Name/Value\n"));
9742
9743   for (entry = dynamic_section;
9744        entry < dynamic_section + dynamic_nent;
9745        entry++)
9746     {
9747       if (do_dynamic)
9748         {
9749           const char * dtype;
9750
9751           putchar (' ');
9752           print_vma (entry->d_tag, FULL_HEX);
9753           dtype = get_dynamic_type (filedata, entry->d_tag);
9754           printf (" (%s)%*s", dtype,
9755                   ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9756         }
9757
9758       switch (entry->d_tag)
9759         {
9760         case DT_FLAGS:
9761           if (do_dynamic)
9762             print_dynamic_flags (entry->d_un.d_val);
9763           break;
9764
9765         case DT_AUXILIARY:
9766         case DT_FILTER:
9767         case DT_CONFIG:
9768         case DT_DEPAUDIT:
9769         case DT_AUDIT:
9770           if (do_dynamic)
9771             {
9772               switch (entry->d_tag)
9773                 {
9774                 case DT_AUXILIARY:
9775                   printf (_("Auxiliary library"));
9776                   break;
9777
9778                 case DT_FILTER:
9779                   printf (_("Filter library"));
9780                   break;
9781
9782                 case DT_CONFIG:
9783                   printf (_("Configuration file"));
9784                   break;
9785
9786                 case DT_DEPAUDIT:
9787                   printf (_("Dependency audit library"));
9788                   break;
9789
9790                 case DT_AUDIT:
9791                   printf (_("Audit library"));
9792                   break;
9793                 }
9794
9795               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9796                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9797               else
9798                 {
9799                   printf (": ");
9800                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9801                   putchar ('\n');
9802                 }
9803             }
9804           break;
9805
9806         case DT_FEATURE:
9807           if (do_dynamic)
9808             {
9809               printf (_("Flags:"));
9810
9811               if (entry->d_un.d_val == 0)
9812                 printf (_(" None\n"));
9813               else
9814                 {
9815                   unsigned long int val = entry->d_un.d_val;
9816
9817                   if (val & DTF_1_PARINIT)
9818                     {
9819                       printf (" PARINIT");
9820                       val ^= DTF_1_PARINIT;
9821                     }
9822                   if (val & DTF_1_CONFEXP)
9823                     {
9824                       printf (" CONFEXP");
9825                       val ^= DTF_1_CONFEXP;
9826                     }
9827                   if (val != 0)
9828                     printf (" %lx", val);
9829                   puts ("");
9830                 }
9831             }
9832           break;
9833
9834         case DT_POSFLAG_1:
9835           if (do_dynamic)
9836             {
9837               printf (_("Flags:"));
9838
9839               if (entry->d_un.d_val == 0)
9840                 printf (_(" None\n"));
9841               else
9842                 {
9843                   unsigned long int val = entry->d_un.d_val;
9844
9845                   if (val & DF_P1_LAZYLOAD)
9846                     {
9847                       printf (" LAZYLOAD");
9848                       val ^= DF_P1_LAZYLOAD;
9849                     }
9850                   if (val & DF_P1_GROUPPERM)
9851                     {
9852                       printf (" GROUPPERM");
9853                       val ^= DF_P1_GROUPPERM;
9854                     }
9855                   if (val != 0)
9856                     printf (" %lx", val);
9857                   puts ("");
9858                 }
9859             }
9860           break;
9861
9862         case DT_FLAGS_1:
9863           if (do_dynamic)
9864             {
9865               printf (_("Flags:"));
9866               if (entry->d_un.d_val == 0)
9867                 printf (_(" None\n"));
9868               else
9869                 {
9870                   unsigned long int val = entry->d_un.d_val;
9871
9872                   if (val & DF_1_NOW)
9873                     {
9874                       printf (" NOW");
9875                       val ^= DF_1_NOW;
9876                     }
9877                   if (val & DF_1_GLOBAL)
9878                     {
9879                       printf (" GLOBAL");
9880                       val ^= DF_1_GLOBAL;
9881                     }
9882                   if (val & DF_1_GROUP)
9883                     {
9884                       printf (" GROUP");
9885                       val ^= DF_1_GROUP;
9886                     }
9887                   if (val & DF_1_NODELETE)
9888                     {
9889                       printf (" NODELETE");
9890                       val ^= DF_1_NODELETE;
9891                     }
9892                   if (val & DF_1_LOADFLTR)
9893                     {
9894                       printf (" LOADFLTR");
9895                       val ^= DF_1_LOADFLTR;
9896                     }
9897                   if (val & DF_1_INITFIRST)
9898                     {
9899                       printf (" INITFIRST");
9900                       val ^= DF_1_INITFIRST;
9901                     }
9902                   if (val & DF_1_NOOPEN)
9903                     {
9904                       printf (" NOOPEN");
9905                       val ^= DF_1_NOOPEN;
9906                     }
9907                   if (val & DF_1_ORIGIN)
9908                     {
9909                       printf (" ORIGIN");
9910                       val ^= DF_1_ORIGIN;
9911                     }
9912                   if (val & DF_1_DIRECT)
9913                     {
9914                       printf (" DIRECT");
9915                       val ^= DF_1_DIRECT;
9916                     }
9917                   if (val & DF_1_TRANS)
9918                     {
9919                       printf (" TRANS");
9920                       val ^= DF_1_TRANS;
9921                     }
9922                   if (val & DF_1_INTERPOSE)
9923                     {
9924                       printf (" INTERPOSE");
9925                       val ^= DF_1_INTERPOSE;
9926                     }
9927                   if (val & DF_1_NODEFLIB)
9928                     {
9929                       printf (" NODEFLIB");
9930                       val ^= DF_1_NODEFLIB;
9931                     }
9932                   if (val & DF_1_NODUMP)
9933                     {
9934                       printf (" NODUMP");
9935                       val ^= DF_1_NODUMP;
9936                     }
9937                   if (val & DF_1_CONFALT)
9938                     {
9939                       printf (" CONFALT");
9940                       val ^= DF_1_CONFALT;
9941                     }
9942                   if (val & DF_1_ENDFILTEE)
9943                     {
9944                       printf (" ENDFILTEE");
9945                       val ^= DF_1_ENDFILTEE;
9946                     }
9947                   if (val & DF_1_DISPRELDNE)
9948                     {
9949                       printf (" DISPRELDNE");
9950                       val ^= DF_1_DISPRELDNE;
9951                     }
9952                   if (val & DF_1_DISPRELPND)
9953                     {
9954                       printf (" DISPRELPND");
9955                       val ^= DF_1_DISPRELPND;
9956                     }
9957                   if (val & DF_1_NODIRECT)
9958                     {
9959                       printf (" NODIRECT");
9960                       val ^= DF_1_NODIRECT;
9961                     }
9962                   if (val & DF_1_IGNMULDEF)
9963                     {
9964                       printf (" IGNMULDEF");
9965                       val ^= DF_1_IGNMULDEF;
9966                     }
9967                   if (val & DF_1_NOKSYMS)
9968                     {
9969                       printf (" NOKSYMS");
9970                       val ^= DF_1_NOKSYMS;
9971                     }
9972                   if (val & DF_1_NOHDR)
9973                     {
9974                       printf (" NOHDR");
9975                       val ^= DF_1_NOHDR;
9976                     }
9977                   if (val & DF_1_EDITED)
9978                     {
9979                       printf (" EDITED");
9980                       val ^= DF_1_EDITED;
9981                     }
9982                   if (val & DF_1_NORELOC)
9983                     {
9984                       printf (" NORELOC");
9985                       val ^= DF_1_NORELOC;
9986                     }
9987                   if (val & DF_1_SYMINTPOSE)
9988                     {
9989                       printf (" SYMINTPOSE");
9990                       val ^= DF_1_SYMINTPOSE;
9991                     }
9992                   if (val & DF_1_GLOBAUDIT)
9993                     {
9994                       printf (" GLOBAUDIT");
9995                       val ^= DF_1_GLOBAUDIT;
9996                     }
9997                   if (val & DF_1_SINGLETON)
9998                     {
9999                       printf (" SINGLETON");
10000                       val ^= DF_1_SINGLETON;
10001                     }
10002                   if (val & DF_1_STUB)
10003                     {
10004                       printf (" STUB");
10005                       val ^= DF_1_STUB;
10006                     }
10007                   if (val & DF_1_PIE)
10008                     {
10009                       printf (" PIE");
10010                       val ^= DF_1_PIE;
10011                     }
10012                   if (val != 0)
10013                     printf (" %lx", val);
10014                   puts ("");
10015                 }
10016             }
10017           break;
10018
10019         case DT_PLTREL:
10020           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10021           if (do_dynamic)
10022             puts (get_dynamic_type (filedata, entry->d_un.d_val));
10023           break;
10024
10025         case DT_NULL    :
10026         case DT_NEEDED  :
10027         case DT_PLTGOT  :
10028         case DT_HASH    :
10029         case DT_STRTAB  :
10030         case DT_SYMTAB  :
10031         case DT_RELA    :
10032         case DT_INIT    :
10033         case DT_FINI    :
10034         case DT_SONAME  :
10035         case DT_RPATH   :
10036         case DT_SYMBOLIC:
10037         case DT_REL     :
10038         case DT_DEBUG   :
10039         case DT_TEXTREL :
10040         case DT_JMPREL  :
10041         case DT_RUNPATH :
10042           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10043
10044           if (do_dynamic)
10045             {
10046               char * name;
10047
10048               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10049                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10050               else
10051                 name = NULL;
10052
10053               if (name)
10054                 {
10055                   switch (entry->d_tag)
10056                     {
10057                     case DT_NEEDED:
10058                       printf (_("Shared library: [%s]"), name);
10059
10060                       if (streq (name, program_interpreter))
10061                         printf (_(" program interpreter"));
10062                       break;
10063
10064                     case DT_SONAME:
10065                       printf (_("Library soname: [%s]"), name);
10066                       break;
10067
10068                     case DT_RPATH:
10069                       printf (_("Library rpath: [%s]"), name);
10070                       break;
10071
10072                     case DT_RUNPATH:
10073                       printf (_("Library runpath: [%s]"), name);
10074                       break;
10075
10076                     default:
10077                       print_vma (entry->d_un.d_val, PREFIX_HEX);
10078                       break;
10079                     }
10080                 }
10081               else
10082                 print_vma (entry->d_un.d_val, PREFIX_HEX);
10083
10084               putchar ('\n');
10085             }
10086           break;
10087
10088         case DT_PLTRELSZ:
10089         case DT_RELASZ  :
10090         case DT_STRSZ   :
10091         case DT_RELSZ   :
10092         case DT_RELAENT :
10093         case DT_SYMENT  :
10094         case DT_RELENT  :
10095           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10096           /* Fall through.  */
10097         case DT_PLTPADSZ:
10098         case DT_MOVEENT :
10099         case DT_MOVESZ  :
10100         case DT_INIT_ARRAYSZ:
10101         case DT_FINI_ARRAYSZ:
10102         case DT_GNU_CONFLICTSZ:
10103         case DT_GNU_LIBLISTSZ:
10104           if (do_dynamic)
10105             {
10106               print_vma (entry->d_un.d_val, UNSIGNED);
10107               printf (_(" (bytes)\n"));
10108             }
10109           break;
10110
10111         case DT_VERDEFNUM:
10112         case DT_VERNEEDNUM:
10113         case DT_RELACOUNT:
10114         case DT_RELCOUNT:
10115           if (do_dynamic)
10116             {
10117               print_vma (entry->d_un.d_val, UNSIGNED);
10118               putchar ('\n');
10119             }
10120           break;
10121
10122         case DT_SYMINSZ:
10123         case DT_SYMINENT:
10124         case DT_SYMINFO:
10125         case DT_USED:
10126         case DT_INIT_ARRAY:
10127         case DT_FINI_ARRAY:
10128           if (do_dynamic)
10129             {
10130               if (entry->d_tag == DT_USED
10131                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10132                 {
10133                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10134
10135                   if (*name)
10136                     {
10137                       printf (_("Not needed object: [%s]\n"), name);
10138                       break;
10139                     }
10140                 }
10141
10142               print_vma (entry->d_un.d_val, PREFIX_HEX);
10143               putchar ('\n');
10144             }
10145           break;
10146
10147         case DT_BIND_NOW:
10148           /* The value of this entry is ignored.  */
10149           if (do_dynamic)
10150             putchar ('\n');
10151           break;
10152
10153         case DT_GNU_PRELINKED:
10154           if (do_dynamic)
10155             {
10156               struct tm * tmp;
10157               time_t atime = entry->d_un.d_val;
10158
10159               tmp = gmtime (&atime);
10160               /* PR 17533 file: 041-1244816-0.004.  */
10161               if (tmp == NULL)
10162                 printf (_("<corrupt time val: %lx"),
10163                         (unsigned long) atime);
10164               else
10165                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10166                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10167                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10168
10169             }
10170           break;
10171
10172         case DT_GNU_HASH:
10173           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10174           if (do_dynamic)
10175             {
10176               print_vma (entry->d_un.d_val, PREFIX_HEX);
10177               putchar ('\n');
10178             }
10179           break;
10180
10181         default:
10182           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10183             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10184               entry->d_un.d_val;
10185
10186           if (do_dynamic)
10187             {
10188               switch (filedata->file_header.e_machine)
10189                 {
10190                 case EM_MIPS:
10191                 case EM_MIPS_RS3_LE:
10192                   dynamic_section_mips_val (entry);
10193                   break;
10194                 case EM_PARISC:
10195                   dynamic_section_parisc_val (entry);
10196                   break;
10197                 case EM_IA_64:
10198                   dynamic_section_ia64_val (entry);
10199                   break;
10200                 default:
10201                   print_vma (entry->d_un.d_val, PREFIX_HEX);
10202                   putchar ('\n');
10203                 }
10204             }
10205           break;
10206         }
10207     }
10208
10209   return TRUE;
10210 }
10211
10212 static char *
10213 get_ver_flags (unsigned int flags)
10214 {
10215   static char buff[128];
10216
10217   buff[0] = 0;
10218
10219   if (flags == 0)
10220     return _("none");
10221
10222   if (flags & VER_FLG_BASE)
10223     strcat (buff, "BASE");
10224
10225   if (flags & VER_FLG_WEAK)
10226     {
10227       if (flags & VER_FLG_BASE)
10228         strcat (buff, " | ");
10229
10230       strcat (buff, "WEAK");
10231     }
10232
10233   if (flags & VER_FLG_INFO)
10234     {
10235       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10236         strcat (buff, " | ");
10237
10238       strcat (buff, "INFO");
10239     }
10240
10241   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10242     {
10243       if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10244         strcat (buff, " | ");
10245
10246       strcat (buff, _("<unknown>"));
10247     }
10248
10249   return buff;
10250 }
10251
10252 /* Display the contents of the version sections.  */
10253
10254 static bfd_boolean
10255 process_version_sections (Filedata * filedata)
10256 {
10257   Elf_Internal_Shdr * section;
10258   unsigned i;
10259   bfd_boolean found = FALSE;
10260
10261   if (! do_version)
10262     return TRUE;
10263
10264   for (i = 0, section = filedata->section_headers;
10265        i < filedata->file_header.e_shnum;
10266        i++, section++)
10267     {
10268       switch (section->sh_type)
10269         {
10270         case SHT_GNU_verdef:
10271           {
10272             Elf_External_Verdef * edefs;
10273             unsigned long idx;
10274             unsigned long cnt;
10275             char * endbuf;
10276
10277             found = TRUE;
10278
10279             printf (ngettext ("\nVersion definition section '%s' "
10280                               "contains %u entry:\n",
10281                               "\nVersion definition section '%s' "
10282                               "contains %u entries:\n",
10283                               section->sh_info),
10284                     printable_section_name (filedata, section),
10285                     section->sh_info);
10286
10287             printf (_("  Addr: 0x"));
10288             printf_vma (section->sh_addr);
10289             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10290                     (unsigned long) section->sh_offset, section->sh_link,
10291                     printable_section_name_from_index (filedata, section->sh_link));
10292
10293             edefs = (Elf_External_Verdef *)
10294                 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
10295                           _("version definition section"));
10296             if (!edefs)
10297               break;
10298             endbuf = (char *) edefs + section->sh_size;
10299
10300             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10301               {
10302                 char * vstart;
10303                 Elf_External_Verdef * edef;
10304                 Elf_Internal_Verdef ent;
10305                 Elf_External_Verdaux * eaux;
10306                 Elf_Internal_Verdaux aux;
10307                 unsigned long isum;
10308                 int j;
10309
10310                 vstart = ((char *) edefs) + idx;
10311                 if (vstart + sizeof (*edef) > endbuf)
10312                   break;
10313
10314                 edef = (Elf_External_Verdef *) vstart;
10315
10316                 ent.vd_version = BYTE_GET (edef->vd_version);
10317                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
10318                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
10319                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
10320                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
10321                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
10322                 ent.vd_next    = BYTE_GET (edef->vd_next);
10323
10324                 printf (_("  %#06lx: Rev: %d  Flags: %s"),
10325                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10326
10327                 printf (_("  Index: %d  Cnt: %d  "),
10328                         ent.vd_ndx, ent.vd_cnt);
10329
10330                 /* Check for overflow.  */
10331                 if (ent.vd_aux > (size_t) (endbuf - vstart))
10332                   break;
10333
10334                 vstart += ent.vd_aux;
10335
10336                 if (vstart + sizeof (*eaux) > endbuf)
10337                   break;
10338                 eaux = (Elf_External_Verdaux *) vstart;
10339
10340                 aux.vda_name = BYTE_GET (eaux->vda_name);
10341                 aux.vda_next = BYTE_GET (eaux->vda_next);
10342
10343                 if (VALID_DYNAMIC_NAME (aux.vda_name))
10344                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10345                 else
10346                   printf (_("Name index: %ld\n"), aux.vda_name);
10347
10348                 isum = idx + ent.vd_aux;
10349
10350                 for (j = 1; j < ent.vd_cnt; j++)
10351                   {
10352                     if (aux.vda_next < sizeof (*eaux)
10353                         && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10354                       {
10355                         warn (_("Invalid vda_next field of %lx\n"),
10356                               aux.vda_next);
10357                         j = ent.vd_cnt;
10358                         break;
10359                       }
10360                     /* Check for overflow.  */
10361                     if (aux.vda_next > (size_t) (endbuf - vstart))
10362                       break;
10363
10364                     isum   += aux.vda_next;
10365                     vstart += aux.vda_next;
10366
10367                     if (vstart + sizeof (*eaux) > endbuf)
10368                       break;
10369                     eaux = (Elf_External_Verdaux *) vstart;
10370
10371                     aux.vda_name = BYTE_GET (eaux->vda_name);
10372                     aux.vda_next = BYTE_GET (eaux->vda_next);
10373
10374                     if (VALID_DYNAMIC_NAME (aux.vda_name))
10375                       printf (_("  %#06lx: Parent %d: %s\n"),
10376                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10377                     else
10378                       printf (_("  %#06lx: Parent %d, name index: %ld\n"),
10379                               isum, j, aux.vda_name);
10380                   }
10381
10382                 if (j < ent.vd_cnt)
10383                   printf (_("  Version def aux past end of section\n"));
10384
10385                 /* PR 17531:
10386                    file: id:000001,src:000172+005151,op:splice,rep:2.  */
10387                 if (ent.vd_next < sizeof (*edef)
10388                     && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10389                   {
10390                     warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10391                     cnt = section->sh_info;
10392                     break;
10393                   }
10394                 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10395                   break;
10396
10397                 idx += ent.vd_next;
10398               }
10399
10400             if (cnt < section->sh_info)
10401               printf (_("  Version definition past end of section\n"));
10402
10403             free (edefs);
10404           }
10405           break;
10406
10407         case SHT_GNU_verneed:
10408           {
10409             Elf_External_Verneed * eneed;
10410             unsigned long idx;
10411             unsigned long cnt;
10412             char * endbuf;
10413
10414             found = TRUE;
10415
10416             printf (ngettext ("\nVersion needs section '%s' "
10417                               "contains %u entry:\n",
10418                               "\nVersion needs section '%s' "
10419                               "contains %u entries:\n",
10420                               section->sh_info),
10421                     printable_section_name (filedata, section), section->sh_info);
10422
10423             printf (_(" Addr: 0x"));
10424             printf_vma (section->sh_addr);
10425             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10426                     (unsigned long) section->sh_offset, section->sh_link,
10427                     printable_section_name_from_index (filedata, section->sh_link));
10428
10429             eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
10430                                                        section->sh_offset, 1,
10431                                                        section->sh_size,
10432                                                        _("Version Needs section"));
10433             if (!eneed)
10434               break;
10435             endbuf = (char *) eneed + section->sh_size;
10436
10437             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10438               {
10439                 Elf_External_Verneed * entry;
10440                 Elf_Internal_Verneed ent;
10441                 unsigned long isum;
10442                 int j;
10443                 char * vstart;
10444
10445                 vstart = ((char *) eneed) + idx;
10446                 if (vstart + sizeof (*entry) > endbuf)
10447                   break;
10448
10449                 entry = (Elf_External_Verneed *) vstart;
10450
10451                 ent.vn_version = BYTE_GET (entry->vn_version);
10452                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
10453                 ent.vn_file    = BYTE_GET (entry->vn_file);
10454                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
10455                 ent.vn_next    = BYTE_GET (entry->vn_next);
10456
10457                 printf (_("  %#06lx: Version: %d"), idx, ent.vn_version);
10458
10459                 if (VALID_DYNAMIC_NAME (ent.vn_file))
10460                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10461                 else
10462                   printf (_("  File: %lx"), ent.vn_file);
10463
10464                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
10465
10466                 /* Check for overflow.  */
10467                 if (ent.vn_aux > (size_t) (endbuf - vstart))
10468                   break;
10469                 vstart += ent.vn_aux;
10470
10471                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10472                   {
10473                     Elf_External_Vernaux * eaux;
10474                     Elf_Internal_Vernaux aux;
10475
10476                     if (vstart + sizeof (*eaux) > endbuf)
10477                       break;
10478                     eaux = (Elf_External_Vernaux *) vstart;
10479
10480                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
10481                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
10482                     aux.vna_other = BYTE_GET (eaux->vna_other);
10483                     aux.vna_name  = BYTE_GET (eaux->vna_name);
10484                     aux.vna_next  = BYTE_GET (eaux->vna_next);
10485
10486                     if (VALID_DYNAMIC_NAME (aux.vna_name))
10487                       printf (_("  %#06lx:   Name: %s"),
10488                               isum, GET_DYNAMIC_NAME (aux.vna_name));
10489                     else
10490                       printf (_("  %#06lx:   Name index: %lx"),
10491                               isum, aux.vna_name);
10492
10493                     printf (_("  Flags: %s  Version: %d\n"),
10494                             get_ver_flags (aux.vna_flags), aux.vna_other);
10495
10496                     if (aux.vna_next < sizeof (*eaux)
10497                         && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10498                       {
10499                         warn (_("Invalid vna_next field of %lx\n"),
10500                               aux.vna_next);
10501                         j = ent.vn_cnt;
10502                         break;
10503                       }
10504                     /* Check for overflow.  */
10505                     if (aux.vna_next > (size_t) (endbuf - vstart))
10506                       break;
10507                     isum   += aux.vna_next;
10508                     vstart += aux.vna_next;
10509                   }
10510
10511                 if (j < ent.vn_cnt)
10512                   warn (_("Missing Version Needs auxillary information\n"));
10513
10514                 if (ent.vn_next < sizeof (*entry)
10515                     && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10516                   {
10517                     warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10518                     cnt = section->sh_info;
10519                     break;
10520                   }
10521                 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10522                   break;
10523                 idx += ent.vn_next;
10524               }
10525
10526             if (cnt < section->sh_info)
10527               warn (_("Missing Version Needs information\n"));
10528
10529             free (eneed);
10530           }
10531           break;
10532
10533         case SHT_GNU_versym:
10534           {
10535             Elf_Internal_Shdr * link_section;
10536             size_t total;
10537             unsigned int cnt;
10538             unsigned char * edata;
10539             unsigned short * data;
10540             char * strtab;
10541             Elf_Internal_Sym * symbols;
10542             Elf_Internal_Shdr * string_sec;
10543             unsigned long num_syms;
10544             long off;
10545
10546             if (section->sh_link >= filedata->file_header.e_shnum)
10547               break;
10548
10549             link_section = filedata->section_headers + section->sh_link;
10550             total = section->sh_size / sizeof (Elf_External_Versym);
10551
10552             if (link_section->sh_link >= filedata->file_header.e_shnum)
10553               break;
10554
10555             found = TRUE;
10556
10557             symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
10558             if (symbols == NULL)
10559               break;
10560
10561             string_sec = filedata->section_headers + link_section->sh_link;
10562
10563             strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
10564                                         string_sec->sh_size,
10565                                         _("version string table"));
10566             if (!strtab)
10567               {
10568                 free (symbols);
10569                 break;
10570               }
10571
10572             printf (ngettext ("\nVersion symbols section '%s' "
10573                               "contains %lu entry:\n",
10574                               "\nVersion symbols section '%s' "
10575                               "contains %lu entries:\n",
10576                               total),
10577                     printable_section_name (filedata, section), (unsigned long) total);
10578
10579             printf (_(" Addr: "));
10580             printf_vma (section->sh_addr);
10581             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10582                     (unsigned long) section->sh_offset, section->sh_link,
10583                     printable_section_name (filedata, link_section));
10584
10585             off = offset_from_vma (filedata,
10586                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10587                                    total * sizeof (short));
10588             edata = (unsigned char *) get_data (NULL, filedata, off, total,
10589                                                 sizeof (short),
10590                                                 _("version symbol data"));
10591             if (!edata)
10592               {
10593                 free (strtab);
10594                 free (symbols);
10595                 break;
10596               }
10597
10598             data = (short unsigned int *) cmalloc (total, sizeof (short));
10599
10600             for (cnt = total; cnt --;)
10601               data[cnt] = byte_get (edata + cnt * sizeof (short),
10602                                     sizeof (short));
10603
10604             free (edata);
10605
10606             for (cnt = 0; cnt < total; cnt += 4)
10607               {
10608                 int j, nn;
10609                 char *name;
10610                 char *invalid = _("*invalid*");
10611
10612                 printf ("  %03x:", cnt);
10613
10614                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10615                   switch (data[cnt + j])
10616                     {
10617                     case 0:
10618                       fputs (_("   0 (*local*)    "), stdout);
10619                       break;
10620
10621                     case 1:
10622                       fputs (_("   1 (*global*)   "), stdout);
10623                       break;
10624
10625                     default:
10626                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10627                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10628
10629                       /* If this index value is greater than the size of the symbols
10630                          array, break to avoid an out-of-bounds read.  */
10631                       if ((unsigned long)(cnt + j) >= num_syms)
10632                         {
10633                           warn (_("invalid index into symbol array\n"));
10634                           break;
10635                         }
10636
10637                       name = NULL;
10638                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10639                         {
10640                           Elf_Internal_Verneed ivn;
10641                           unsigned long offset;
10642
10643                           offset = offset_from_vma
10644                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10645                              sizeof (Elf_External_Verneed));
10646
10647                           do
10648                             {
10649                               Elf_Internal_Vernaux ivna;
10650                               Elf_External_Verneed evn;
10651                               Elf_External_Vernaux evna;
10652                               unsigned long a_off;
10653
10654                               if (get_data (&evn, filedata, offset, sizeof (evn), 1,
10655                                             _("version need")) == NULL)
10656                                 break;
10657
10658                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10659                               ivn.vn_next = BYTE_GET (evn.vn_next);
10660
10661                               a_off = offset + ivn.vn_aux;
10662
10663                               do
10664                                 {
10665                                   if (get_data (&evna, filedata, a_off, sizeof (evna),
10666                                                 1, _("version need aux (2)")) == NULL)
10667                                     {
10668                                       ivna.vna_next  = 0;
10669                                       ivna.vna_other = 0;
10670                                     }
10671                                   else
10672                                     {
10673                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
10674                                       ivna.vna_other = BYTE_GET (evna.vna_other);
10675                                     }
10676
10677                                   a_off += ivna.vna_next;
10678                                 }
10679                               while (ivna.vna_other != data[cnt + j]
10680                                      && ivna.vna_next != 0);
10681
10682                               if (ivna.vna_other == data[cnt + j])
10683                                 {
10684                                   ivna.vna_name = BYTE_GET (evna.vna_name);
10685
10686                                   if (ivna.vna_name >= string_sec->sh_size)
10687                                     name = invalid;
10688                                   else
10689                                     name = strtab + ivna.vna_name;
10690                                   break;
10691                                 }
10692
10693                               offset += ivn.vn_next;
10694                             }
10695                           while (ivn.vn_next);
10696                         }
10697
10698                       if (data[cnt + j] != 0x8001
10699                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10700                         {
10701                           Elf_Internal_Verdef ivd;
10702                           Elf_External_Verdef evd;
10703                           unsigned long offset;
10704
10705                           offset = offset_from_vma
10706                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10707                              sizeof evd);
10708
10709                           do
10710                             {
10711                               if (get_data (&evd, filedata, offset, sizeof (evd), 1,
10712                                             _("version def")) == NULL)
10713                                 {
10714                                   ivd.vd_next = 0;
10715                                   /* PR 17531: file: 046-1082287-0.004.  */
10716                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
10717                                   break;
10718                                 }
10719                               else
10720                                 {
10721                                   ivd.vd_next = BYTE_GET (evd.vd_next);
10722                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
10723                                 }
10724
10725                               offset += ivd.vd_next;
10726                             }
10727                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10728                                  && ivd.vd_next != 0);
10729
10730                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10731                             {
10732                               Elf_External_Verdaux evda;
10733                               Elf_Internal_Verdaux ivda;
10734
10735                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
10736
10737                               if (get_data (&evda, filedata,
10738                                             offset - ivd.vd_next + ivd.vd_aux,
10739                                             sizeof (evda), 1,
10740                                             _("version def aux")) == NULL)
10741                                 break;
10742
10743                               ivda.vda_name = BYTE_GET (evda.vda_name);
10744
10745                               if (ivda.vda_name >= string_sec->sh_size)
10746                                 name = invalid;
10747                               else if (name != NULL && name != invalid)
10748                                 name = _("*both*");
10749                               else
10750                                 name = strtab + ivda.vda_name;
10751                             }
10752                         }
10753                       if (name != NULL)
10754                         nn += printf ("(%s%-*s",
10755                                       name,
10756                                       12 - (int) strlen (name),
10757                                       ")");
10758
10759                       if (nn < 18)
10760                         printf ("%*c", 18 - nn, ' ');
10761                     }
10762
10763                 putchar ('\n');
10764               }
10765
10766             free (data);
10767             free (strtab);
10768             free (symbols);
10769           }
10770           break;
10771
10772         default:
10773           break;
10774         }
10775     }
10776
10777   if (! found)
10778     printf (_("\nNo version information found in this file.\n"));
10779
10780   return TRUE;
10781 }
10782
10783 static const char *
10784 get_symbol_binding (Filedata * filedata, unsigned int binding)
10785 {
10786   static char buff[32];
10787
10788   switch (binding)
10789     {
10790     case STB_LOCAL:     return "LOCAL";
10791     case STB_GLOBAL:    return "GLOBAL";
10792     case STB_WEAK:      return "WEAK";
10793     default:
10794       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10795         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10796                   binding);
10797       else if (binding >= STB_LOOS && binding <= STB_HIOS)
10798         {
10799           if (binding == STB_GNU_UNIQUE
10800               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10801                   /* GNU is still using the default value 0.  */
10802                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10803             return "UNIQUE";
10804           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10805         }
10806       else
10807         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10808       return buff;
10809     }
10810 }
10811
10812 static const char *
10813 get_symbol_type (Filedata * filedata, unsigned int type)
10814 {
10815   static char buff[32];
10816
10817   switch (type)
10818     {
10819     case STT_NOTYPE:    return "NOTYPE";
10820     case STT_OBJECT:    return "OBJECT";
10821     case STT_FUNC:      return "FUNC";
10822     case STT_SECTION:   return "SECTION";
10823     case STT_FILE:      return "FILE";
10824     case STT_COMMON:    return "COMMON";
10825     case STT_TLS:       return "TLS";
10826     case STT_RELC:      return "RELC";
10827     case STT_SRELC:     return "SRELC";
10828     default:
10829       if (type >= STT_LOPROC && type <= STT_HIPROC)
10830         {
10831           if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10832             return "THUMB_FUNC";
10833
10834           if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10835             return "REGISTER";
10836
10837           if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10838             return "PARISC_MILLI";
10839
10840           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10841         }
10842       else if (type >= STT_LOOS && type <= STT_HIOS)
10843         {
10844           if (filedata->file_header.e_machine == EM_PARISC)
10845             {
10846               if (type == STT_HP_OPAQUE)
10847                 return "HP_OPAQUE";
10848               if (type == STT_HP_STUB)
10849                 return "HP_STUB";
10850             }
10851
10852           if (type == STT_GNU_IFUNC
10853               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10854                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10855                   /* GNU is still using the default value 0.  */
10856                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10857             return "IFUNC";
10858
10859           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10860         }
10861       else
10862         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10863       return buff;
10864     }
10865 }
10866
10867 static const char *
10868 get_symbol_visibility (unsigned int visibility)
10869 {
10870   switch (visibility)
10871     {
10872     case STV_DEFAULT:   return "DEFAULT";
10873     case STV_INTERNAL:  return "INTERNAL";
10874     case STV_HIDDEN:    return "HIDDEN";
10875     case STV_PROTECTED: return "PROTECTED";
10876     default:
10877       error (_("Unrecognized visibility value: %u"), visibility);
10878       return _("<unknown>");
10879     }
10880 }
10881
10882 static const char *
10883 get_solaris_symbol_visibility (unsigned int visibility)
10884 {
10885   switch (visibility)
10886     {
10887     case 4: return "EXPORTED";
10888     case 5: return "SINGLETON";
10889     case 6: return "ELIMINATE";
10890     default: return get_symbol_visibility (visibility);
10891     }
10892 }
10893
10894 static const char *
10895 get_mips_symbol_other (unsigned int other)
10896 {
10897   switch (other)
10898     {
10899     case STO_OPTIONAL:      return "OPTIONAL";
10900     case STO_MIPS_PLT:      return "MIPS PLT";
10901     case STO_MIPS_PIC:      return "MIPS PIC";
10902     case STO_MICROMIPS:     return "MICROMIPS";
10903     case STO_MICROMIPS | STO_MIPS_PIC:      return "MICROMIPS, MIPS PIC";
10904     case STO_MIPS16:        return "MIPS16";
10905     default:                return NULL;
10906     }
10907 }
10908
10909 static const char *
10910 get_ia64_symbol_other (Filedata * filedata, unsigned int other)
10911 {
10912   if (is_ia64_vms (filedata))
10913     {
10914       static char res[32];
10915
10916       res[0] = 0;
10917
10918       /* Function types is for images and .STB files only.  */
10919       switch (filedata->file_header.e_type)
10920         {
10921         case ET_DYN:
10922         case ET_EXEC:
10923           switch (VMS_ST_FUNC_TYPE (other))
10924             {
10925             case VMS_SFT_CODE_ADDR:
10926               strcat (res, " CA");
10927               break;
10928             case VMS_SFT_SYMV_IDX:
10929               strcat (res, " VEC");
10930               break;
10931             case VMS_SFT_FD:
10932               strcat (res, " FD");
10933               break;
10934             case VMS_SFT_RESERVE:
10935               strcat (res, " RSV");
10936               break;
10937             default:
10938               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10939                     VMS_ST_FUNC_TYPE (other));
10940               strcat (res, " <unknown>");
10941               break;
10942             }
10943           break;
10944         default:
10945           break;
10946         }
10947       switch (VMS_ST_LINKAGE (other))
10948         {
10949         case VMS_STL_IGNORE:
10950           strcat (res, " IGN");
10951           break;
10952         case VMS_STL_RESERVE:
10953           strcat (res, " RSV");
10954           break;
10955         case VMS_STL_STD:
10956           strcat (res, " STD");
10957           break;
10958         case VMS_STL_LNK:
10959           strcat (res, " LNK");
10960           break;
10961         default:
10962           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10963                 VMS_ST_LINKAGE (other));
10964           strcat (res, " <unknown>");
10965           break;
10966         }
10967
10968       if (res[0] != 0)
10969         return res + 1;
10970       else
10971         return res;
10972     }
10973   return NULL;
10974 }
10975
10976 static const char *
10977 get_ppc64_symbol_other (unsigned int other)
10978 {
10979   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10980     {
10981       static char buf[32];
10982       snprintf (buf, sizeof buf, _("<localentry>: %d"),
10983                 PPC64_LOCAL_ENTRY_OFFSET (other));
10984       return buf;
10985     }
10986   return NULL;
10987 }
10988
10989 static const char *
10990 get_symbol_other (Filedata * filedata, unsigned int other)
10991 {
10992   const char * result = NULL;
10993   static char buff [32];
10994
10995   if (other == 0)
10996     return "";
10997
10998   switch (filedata->file_header.e_machine)
10999     {
11000     case EM_MIPS:
11001       result = get_mips_symbol_other (other);
11002       break;
11003     case EM_IA_64:
11004       result = get_ia64_symbol_other (filedata, other);
11005       break;
11006     case EM_PPC64:
11007       result = get_ppc64_symbol_other (other);
11008       break;
11009     default:
11010       result = NULL;
11011       break;
11012     }
11013
11014   if (result)
11015     return result;
11016
11017   snprintf (buff, sizeof buff, _("<other>: %x"), other);
11018   return buff;
11019 }
11020
11021 static const char *
11022 get_symbol_index_type (Filedata * filedata, unsigned int type)
11023 {
11024   static char buff[32];
11025
11026   switch (type)
11027     {
11028     case SHN_UNDEF:     return "UND";
11029     case SHN_ABS:       return "ABS";
11030     case SHN_COMMON:    return "COM";
11031     default:
11032       if (type == SHN_IA_64_ANSI_COMMON
11033           && filedata->file_header.e_machine == EM_IA_64
11034           && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11035         return "ANSI_COM";
11036       else if ((filedata->file_header.e_machine == EM_X86_64
11037                 || filedata->file_header.e_machine == EM_L1OM
11038                 || filedata->file_header.e_machine == EM_K1OM)
11039                && type == SHN_X86_64_LCOMMON)
11040         return "LARGE_COM";
11041       else if ((type == SHN_MIPS_SCOMMON
11042                 && filedata->file_header.e_machine == EM_MIPS)
11043                || (type == SHN_TIC6X_SCOMMON
11044                    && filedata->file_header.e_machine == EM_TI_C6000))
11045         return "SCOM";
11046       else if (type == SHN_MIPS_SUNDEFINED
11047                && filedata->file_header.e_machine == EM_MIPS)
11048         return "SUND";
11049       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11050         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11051       else if (type >= SHN_LOOS && type <= SHN_HIOS)
11052         sprintf (buff, "OS [0x%04x]", type & 0xffff);
11053       else if (type >= SHN_LORESERVE)
11054         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11055       else if (type >= filedata->file_header.e_shnum)
11056         sprintf (buff, _("bad section index[%3d]"), type);
11057       else
11058         sprintf (buff, "%3d", type);
11059       break;
11060     }
11061
11062   return buff;
11063 }
11064
11065 static bfd_vma *
11066 get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
11067 {
11068   unsigned char * e_data;
11069   bfd_vma * i_data;
11070
11071   /* If the size_t type is smaller than the bfd_size_type, eg because
11072      you are building a 32-bit tool on a 64-bit host, then make sure
11073      that when (number) is cast to (size_t) no information is lost.  */
11074   if (sizeof (size_t) < sizeof (bfd_size_type)
11075       && (bfd_size_type) ((size_t) number) != number)
11076     {
11077       error (_("Size truncation prevents reading %s elements of size %u\n"),
11078              bfd_vmatoa ("u", number), ent_size);
11079       return NULL;
11080     }
11081
11082   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11083      attempting to allocate memory when the read is bound to fail.  */
11084   if (ent_size * number > filedata->file_size)
11085     {
11086       error (_("Invalid number of dynamic entries: %s\n"),
11087              bfd_vmatoa ("u", number));
11088       return NULL;
11089     }
11090
11091   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11092   if (e_data == NULL)
11093     {
11094       error (_("Out of memory reading %s dynamic entries\n"),
11095              bfd_vmatoa ("u", number));
11096       return NULL;
11097     }
11098
11099   if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
11100     {
11101       error (_("Unable to read in %s bytes of dynamic data\n"),
11102              bfd_vmatoa ("u", number * ent_size));
11103       free (e_data);
11104       return NULL;
11105     }
11106
11107   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11108   if (i_data == NULL)
11109     {
11110       error (_("Out of memory allocating space for %s dynamic entries\n"),
11111              bfd_vmatoa ("u", number));
11112       free (e_data);
11113       return NULL;
11114     }
11115
11116   while (number--)
11117     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11118
11119   free (e_data);
11120
11121   return i_data;
11122 }
11123
11124 static void
11125 print_dynamic_symbol (Filedata * filedata, bfd_vma si, unsigned long hn)
11126 {
11127   Elf_Internal_Sym * psym;
11128   int n;
11129
11130   n = print_vma (si, DEC_5);
11131   if (n < 5)
11132     fputs (&"     "[n], stdout);
11133   printf (" %3lu: ", hn);
11134
11135   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11136     {
11137       printf (_("<No info available for dynamic symbol number %lu>\n"),
11138               (unsigned long) si);
11139       return;
11140     }
11141
11142   psym = dynamic_symbols + si;
11143   print_vma (psym->st_value, LONG_HEX);
11144   putchar (' ');
11145   print_vma (psym->st_size, DEC_5);
11146
11147   printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11148   printf (" %-6s",  get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11149
11150   if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11151     printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11152   else
11153     {
11154       unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11155
11156       printf (" %-7s",  get_symbol_visibility (vis));
11157       /* Check to see if any other bits in the st_other field are set.
11158          Note - displaying this information disrupts the layout of the
11159          table being generated, but for the moment this case is very
11160          rare.  */
11161       if (psym->st_other ^ vis)
11162         printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11163     }
11164
11165   printf (" %3.3s ", get_symbol_index_type (filedata, psym->st_shndx));
11166   if (VALID_DYNAMIC_NAME (psym->st_name))
11167     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11168   else
11169     printf (_(" <corrupt: %14ld>"), psym->st_name);
11170   putchar ('\n');
11171 }
11172
11173 static const char *
11174 get_symbol_version_string (Filedata *                   filedata,
11175                            bfd_boolean                  is_dynsym,
11176                            const char *                 strtab,
11177                            unsigned long int            strtab_size,
11178                            unsigned int                 si,
11179                            Elf_Internal_Sym *           psym,
11180                            enum versioned_symbol_info * sym_info,
11181                            unsigned short *             vna_other)
11182 {
11183   unsigned char data[2];
11184   unsigned short vers_data;
11185   unsigned long offset;
11186
11187   if (!is_dynsym
11188       || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11189     return NULL;
11190
11191   offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11192                             sizeof data + si * sizeof (vers_data));
11193
11194   if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11195                 sizeof (data), 1, _("version data")) == NULL)
11196     return NULL;
11197
11198   vers_data = byte_get (data, 2);
11199
11200   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
11201     return NULL;
11202
11203   /* Usually we'd only see verdef for defined symbols, and verneed for
11204      undefined symbols.  However, symbols defined by the linker in
11205      .dynbss for variables copied from a shared library in order to
11206      avoid text relocations are defined yet have verneed.  We could
11207      use a heuristic to detect the special case, for example, check
11208      for verneed first on symbols defined in SHT_NOBITS sections, but
11209      it is simpler and more reliable to just look for both verdef and
11210      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
11211
11212   if (psym->st_shndx != SHN_UNDEF
11213       && vers_data != 0x8001
11214       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11215     {
11216       Elf_Internal_Verdef ivd;
11217       Elf_Internal_Verdaux ivda;
11218       Elf_External_Verdaux evda;
11219       unsigned long off;
11220
11221       off = offset_from_vma (filedata,
11222                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11223                              sizeof (Elf_External_Verdef));
11224
11225       do
11226         {
11227           Elf_External_Verdef evd;
11228
11229           if (get_data (&evd, filedata, off, sizeof (evd), 1,
11230                         _("version def")) == NULL)
11231             {
11232               ivd.vd_ndx = 0;
11233               ivd.vd_aux = 0;
11234               ivd.vd_next = 0;
11235             }
11236           else
11237             {
11238               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11239               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11240               ivd.vd_next = BYTE_GET (evd.vd_next);
11241             }
11242
11243           off += ivd.vd_next;
11244         }
11245       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11246
11247       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11248         {
11249           off -= ivd.vd_next;
11250           off += ivd.vd_aux;
11251
11252           if (get_data (&evda, filedata, off, sizeof (evda), 1,
11253                         _("version def aux")) != NULL)
11254             {
11255               ivda.vda_name = BYTE_GET (evda.vda_name);
11256
11257               if (psym->st_name != ivda.vda_name)
11258                 {
11259                   *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11260                                ? symbol_hidden : symbol_public);
11261                   return (ivda.vda_name < strtab_size
11262                           ? strtab + ivda.vda_name : _("<corrupt>"));
11263                 }
11264             }
11265         }
11266     }
11267
11268   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11269     {
11270       Elf_External_Verneed evn;
11271       Elf_Internal_Verneed ivn;
11272       Elf_Internal_Vernaux ivna;
11273
11274       offset = offset_from_vma (filedata,
11275                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11276                                 sizeof evn);
11277       do
11278         {
11279           unsigned long vna_off;
11280
11281           if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11282                         _("version need")) == NULL)
11283             {
11284               ivna.vna_next = 0;
11285               ivna.vna_other = 0;
11286               ivna.vna_name = 0;
11287               break;
11288             }
11289
11290           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
11291           ivn.vn_next = BYTE_GET (evn.vn_next);
11292
11293           vna_off = offset + ivn.vn_aux;
11294
11295           do
11296             {
11297               Elf_External_Vernaux evna;
11298
11299               if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11300                             _("version need aux (3)")) == NULL)
11301                 {
11302                   ivna.vna_next = 0;
11303                   ivna.vna_other = 0;
11304                   ivna.vna_name = 0;
11305                 }
11306               else
11307                 {
11308                   ivna.vna_other = BYTE_GET (evna.vna_other);
11309                   ivna.vna_next  = BYTE_GET (evna.vna_next);
11310                   ivna.vna_name  = BYTE_GET (evna.vna_name);
11311                 }
11312
11313               vna_off += ivna.vna_next;
11314             }
11315           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11316
11317           if (ivna.vna_other == vers_data)
11318             break;
11319
11320           offset += ivn.vn_next;
11321         }
11322       while (ivn.vn_next != 0);
11323
11324       if (ivna.vna_other == vers_data)
11325         {
11326           *sym_info = symbol_undefined;
11327           *vna_other = ivna.vna_other;
11328           return (ivna.vna_name < strtab_size
11329                   ? strtab + ivna.vna_name : _("<corrupt>"));
11330         }
11331     }
11332   return NULL;
11333 }
11334
11335 /* Dump the symbol table.  */
11336 static bfd_boolean
11337 process_symbol_table (Filedata * filedata)
11338 {
11339   Elf_Internal_Shdr * section;
11340   bfd_size_type nbuckets = 0;
11341   bfd_size_type nchains = 0;
11342   bfd_vma * buckets = NULL;
11343   bfd_vma * chains = NULL;
11344   bfd_vma ngnubuckets = 0;
11345   bfd_vma * gnubuckets = NULL;
11346   bfd_vma * gnuchains = NULL;
11347   bfd_vma gnusymidx = 0;
11348   bfd_size_type ngnuchains = 0;
11349
11350   if (!do_syms && !do_dyn_syms && !do_histogram)
11351     return TRUE;
11352
11353   if (dynamic_info[DT_HASH]
11354       && (do_histogram
11355           || (do_using_dynamic
11356               && !do_dyn_syms
11357               && dynamic_strings != NULL)))
11358     {
11359       unsigned char nb[8];
11360       unsigned char nc[8];
11361       unsigned int hash_ent_size = 4;
11362
11363       if ((filedata->file_header.e_machine == EM_ALPHA
11364            || filedata->file_header.e_machine == EM_S390
11365            || filedata->file_header.e_machine == EM_S390_OLD)
11366           && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11367         hash_ent_size = 8;
11368
11369       if (fseek (filedata->handle,
11370                  (archive_file_offset
11371                   + offset_from_vma (filedata, dynamic_info[DT_HASH],
11372                                      sizeof nb + sizeof nc)),
11373                  SEEK_SET))
11374         {
11375           error (_("Unable to seek to start of dynamic information\n"));
11376           goto no_hash;
11377         }
11378
11379       if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11380         {
11381           error (_("Failed to read in number of buckets\n"));
11382           goto no_hash;
11383         }
11384
11385       if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11386         {
11387           error (_("Failed to read in number of chains\n"));
11388           goto no_hash;
11389         }
11390
11391       nbuckets = byte_get (nb, hash_ent_size);
11392       nchains  = byte_get (nc, hash_ent_size);
11393
11394       buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11395       chains  = get_dynamic_data (filedata, nchains, hash_ent_size);
11396
11397     no_hash:
11398       if (buckets == NULL || chains == NULL)
11399         {
11400           if (do_using_dynamic)
11401             return FALSE;
11402           free (buckets);
11403           free (chains);
11404           buckets = NULL;
11405           chains = NULL;
11406           nbuckets = 0;
11407           nchains = 0;
11408         }
11409     }
11410
11411   if (dynamic_info_DT_GNU_HASH
11412       && (do_histogram
11413           || (do_using_dynamic
11414               && !do_dyn_syms
11415               && dynamic_strings != NULL)))
11416     {
11417       unsigned char nb[16];
11418       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11419       bfd_vma buckets_vma;
11420
11421       if (fseek (filedata->handle,
11422                  (archive_file_offset
11423                   + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11424                                      sizeof nb)),
11425                  SEEK_SET))
11426         {
11427           error (_("Unable to seek to start of dynamic information\n"));
11428           goto no_gnu_hash;
11429         }
11430
11431       if (fread (nb, 16, 1, filedata->handle) != 1)
11432         {
11433           error (_("Failed to read in number of buckets\n"));
11434           goto no_gnu_hash;
11435         }
11436
11437       ngnubuckets = byte_get (nb, 4);
11438       gnusymidx = byte_get (nb + 4, 4);
11439       bitmaskwords = byte_get (nb + 8, 4);
11440       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11441       if (is_32bit_elf)
11442         buckets_vma += bitmaskwords * 4;
11443       else
11444         buckets_vma += bitmaskwords * 8;
11445
11446       if (fseek (filedata->handle,
11447                  (archive_file_offset
11448                   + offset_from_vma (filedata, buckets_vma, 4)),
11449                  SEEK_SET))
11450         {
11451           error (_("Unable to seek to start of dynamic information\n"));
11452           goto no_gnu_hash;
11453         }
11454
11455       gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11456
11457       if (gnubuckets == NULL)
11458         goto no_gnu_hash;
11459
11460       for (i = 0; i < ngnubuckets; i++)
11461         if (gnubuckets[i] != 0)
11462           {
11463             if (gnubuckets[i] < gnusymidx)
11464               return FALSE;
11465
11466             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11467               maxchain = gnubuckets[i];
11468           }
11469
11470       if (maxchain == 0xffffffff)
11471         goto no_gnu_hash;
11472
11473       maxchain -= gnusymidx;
11474
11475       if (fseek (filedata->handle,
11476                  (archive_file_offset
11477                   + offset_from_vma (filedata, buckets_vma
11478                                            + 4 * (ngnubuckets + maxchain), 4)),
11479                  SEEK_SET))
11480         {
11481           error (_("Unable to seek to start of dynamic information\n"));
11482           goto no_gnu_hash;
11483         }
11484
11485       do
11486         {
11487           if (fread (nb, 4, 1, filedata->handle) != 1)
11488             {
11489               error (_("Failed to determine last chain length\n"));
11490               goto no_gnu_hash;
11491             }
11492
11493           if (maxchain + 1 == 0)
11494             goto no_gnu_hash;
11495
11496           ++maxchain;
11497         }
11498       while ((byte_get (nb, 4) & 1) == 0);
11499
11500       if (fseek (filedata->handle,
11501                  (archive_file_offset
11502                   + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11503                  SEEK_SET))
11504         {
11505           error (_("Unable to seek to start of dynamic information\n"));
11506           goto no_gnu_hash;
11507         }
11508
11509       gnuchains = get_dynamic_data (filedata, maxchain, 4);
11510       ngnuchains = maxchain;
11511
11512     no_gnu_hash:
11513       if (gnuchains == NULL)
11514         {
11515           free (gnubuckets);
11516           gnubuckets = NULL;
11517           ngnubuckets = 0;
11518           if (do_using_dynamic)
11519             return FALSE;
11520         }
11521     }
11522
11523   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11524       && do_syms
11525       && do_using_dynamic
11526       && dynamic_strings != NULL
11527       && dynamic_symbols != NULL)
11528     {
11529       unsigned long hn;
11530
11531       if (dynamic_info[DT_HASH])
11532         {
11533           bfd_vma si;
11534           char *visited;
11535
11536           printf (_("\nSymbol table for image:\n"));
11537           if (is_32bit_elf)
11538             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11539           else
11540             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11541
11542           visited = xcmalloc (nchains, 1);
11543           memset (visited, 0, nchains);
11544           for (hn = 0; hn < nbuckets; hn++)
11545             {
11546               for (si = buckets[hn]; si > 0; si = chains[si])
11547                 {
11548                   print_dynamic_symbol (filedata, si, hn);
11549                   if (si >= nchains || visited[si])
11550                     {
11551                       error (_("histogram chain is corrupt\n"));
11552                       break;
11553                     }
11554                   visited[si] = 1;
11555                 }
11556             }
11557           free (visited);
11558         }
11559
11560       if (dynamic_info_DT_GNU_HASH)
11561         {
11562           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11563           if (is_32bit_elf)
11564             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11565           else
11566             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11567
11568           for (hn = 0; hn < ngnubuckets; ++hn)
11569             if (gnubuckets[hn] != 0)
11570               {
11571                 bfd_vma si = gnubuckets[hn];
11572                 bfd_vma off = si - gnusymidx;
11573
11574                 do
11575                   {
11576                     print_dynamic_symbol (filedata, si, hn);
11577                     si++;
11578                   }
11579                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11580               }
11581         }
11582     }
11583   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11584            && filedata->section_headers != NULL)
11585     {
11586       unsigned int i;
11587
11588       for (i = 0, section = filedata->section_headers;
11589            i < filedata->file_header.e_shnum;
11590            i++, section++)
11591         {
11592           unsigned int si;
11593           char * strtab = NULL;
11594           unsigned long int strtab_size = 0;
11595           Elf_Internal_Sym * symtab;
11596           Elf_Internal_Sym * psym;
11597           unsigned long num_syms;
11598
11599           if ((section->sh_type != SHT_SYMTAB
11600                && section->sh_type != SHT_DYNSYM)
11601               || (!do_syms
11602                   && section->sh_type == SHT_SYMTAB))
11603             continue;
11604
11605           if (section->sh_entsize == 0)
11606             {
11607               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11608                       printable_section_name (filedata, section));
11609               continue;
11610             }
11611
11612           num_syms = section->sh_size / section->sh_entsize;
11613           printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11614                             "\nSymbol table '%s' contains %lu entries:\n",
11615                             num_syms),
11616                   printable_section_name (filedata, section),
11617                   num_syms);
11618
11619           if (is_32bit_elf)
11620             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
11621           else
11622             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
11623
11624           symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
11625           if (symtab == NULL)
11626             continue;
11627
11628           if (section->sh_link == filedata->file_header.e_shstrndx)
11629             {
11630               strtab = filedata->string_table;
11631               strtab_size = filedata->string_table_length;
11632             }
11633           else if (section->sh_link < filedata->file_header.e_shnum)
11634             {
11635               Elf_Internal_Shdr * string_sec;
11636
11637               string_sec = filedata->section_headers + section->sh_link;
11638
11639               strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
11640                                           1, string_sec->sh_size,
11641                                           _("string table"));
11642               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11643             }
11644
11645           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11646             {
11647               const char *version_string;
11648               enum versioned_symbol_info sym_info;
11649               unsigned short vna_other;
11650
11651               printf ("%6d: ", si);
11652               print_vma (psym->st_value, LONG_HEX);
11653               putchar (' ');
11654               print_vma (psym->st_size, DEC_5);
11655               printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11656               printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11657               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11658                 printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11659               else
11660                 {
11661                   unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11662
11663                   printf (" %-7s", get_symbol_visibility (vis));
11664                   /* Check to see if any other bits in the st_other field are set.
11665                      Note - displaying this information disrupts the layout of the
11666                      table being generated, but for the moment this case is very rare.  */
11667                   if (psym->st_other ^ vis)
11668                     printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11669                 }
11670               printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
11671               print_symbol (25, psym->st_name < strtab_size
11672                             ? strtab + psym->st_name : _("<corrupt>"));
11673
11674               version_string
11675                 = get_symbol_version_string (filedata,
11676                                              section->sh_type == SHT_DYNSYM,
11677                                              strtab, strtab_size, si,
11678                                              psym, &sym_info, &vna_other);
11679               if (version_string)
11680                 {
11681                   if (sym_info == symbol_undefined)
11682                     printf ("@%s (%d)", version_string, vna_other);
11683                   else
11684                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11685                             version_string);
11686                 }
11687
11688               putchar ('\n');
11689
11690               if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11691                   && si >= section->sh_info
11692                   /* Irix 5 and 6 MIPS binaries are known to ignore this requirement.  */
11693                   && filedata->file_header.e_machine != EM_MIPS
11694                   /* Solaris binaries have been found to violate this requirement as
11695                      well.  Not sure if this is a bug or an ABI requirement.  */
11696                   && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11697                 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11698                       si, printable_section_name (filedata, section), section->sh_info);
11699             }
11700
11701           free (symtab);
11702           if (strtab != filedata->string_table)
11703             free (strtab);
11704         }
11705     }
11706   else if (do_syms)
11707     printf
11708       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11709
11710   if (do_histogram && buckets != NULL)
11711     {
11712       unsigned long * lengths;
11713       unsigned long * counts;
11714       unsigned long hn;
11715       bfd_vma si;
11716       unsigned long maxlength = 0;
11717       unsigned long nzero_counts = 0;
11718       unsigned long nsyms = 0;
11719       char *visited;
11720
11721       printf (ngettext ("\nHistogram for bucket list length "
11722                         "(total of %lu bucket):\n",
11723                         "\nHistogram for bucket list length "
11724                         "(total of %lu buckets):\n",
11725                         (unsigned long) nbuckets),
11726               (unsigned long) nbuckets);
11727
11728       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11729       if (lengths == NULL)
11730         {
11731           error (_("Out of memory allocating space for histogram buckets\n"));
11732           return FALSE;
11733         }
11734       visited = xcmalloc (nchains, 1);
11735       memset (visited, 0, nchains);
11736
11737       printf (_(" Length  Number     %% of total  Coverage\n"));
11738       for (hn = 0; hn < nbuckets; ++hn)
11739         {
11740           for (si = buckets[hn]; si > 0; si = chains[si])
11741             {
11742               ++nsyms;
11743               if (maxlength < ++lengths[hn])
11744                 ++maxlength;
11745               if (si >= nchains || visited[si])
11746                 {
11747                   error (_("histogram chain is corrupt\n"));
11748                   break;
11749                 }
11750               visited[si] = 1;
11751             }
11752         }
11753       free (visited);
11754
11755       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11756       if (counts == NULL)
11757         {
11758           free (lengths);
11759           error (_("Out of memory allocating space for histogram counts\n"));
11760           return FALSE;
11761         }
11762
11763       for (hn = 0; hn < nbuckets; ++hn)
11764         ++counts[lengths[hn]];
11765
11766       if (nbuckets > 0)
11767         {
11768           unsigned long i;
11769           printf ("      0  %-10lu (%5.1f%%)\n",
11770                   counts[0], (counts[0] * 100.0) / nbuckets);
11771           for (i = 1; i <= maxlength; ++i)
11772             {
11773               nzero_counts += counts[i] * i;
11774               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11775                       i, counts[i], (counts[i] * 100.0) / nbuckets,
11776                       (nzero_counts * 100.0) / nsyms);
11777             }
11778         }
11779
11780       free (counts);
11781       free (lengths);
11782     }
11783
11784   if (buckets != NULL)
11785     {
11786       free (buckets);
11787       free (chains);
11788     }
11789
11790   if (do_histogram && gnubuckets != NULL)
11791     {
11792       unsigned long * lengths;
11793       unsigned long * counts;
11794       unsigned long hn;
11795       unsigned long maxlength = 0;
11796       unsigned long nzero_counts = 0;
11797       unsigned long nsyms = 0;
11798
11799       printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11800                         "(total of %lu bucket):\n",
11801                         "\nHistogram for `.gnu.hash' bucket list length "
11802                         "(total of %lu buckets):\n",
11803                         (unsigned long) ngnubuckets),
11804               (unsigned long) ngnubuckets);
11805
11806       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11807       if (lengths == NULL)
11808         {
11809           error (_("Out of memory allocating space for gnu histogram buckets\n"));
11810           return FALSE;
11811         }
11812
11813       printf (_(" Length  Number     %% of total  Coverage\n"));
11814
11815       for (hn = 0; hn < ngnubuckets; ++hn)
11816         if (gnubuckets[hn] != 0)
11817           {
11818             bfd_vma off, length = 1;
11819
11820             for (off = gnubuckets[hn] - gnusymidx;
11821                  /* PR 17531 file: 010-77222-0.004.  */
11822                  off < ngnuchains && (gnuchains[off] & 1) == 0;
11823                  ++off)
11824               ++length;
11825             lengths[hn] = length;
11826             if (length > maxlength)
11827               maxlength = length;
11828             nsyms += length;
11829           }
11830
11831       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11832       if (counts == NULL)
11833         {
11834           free (lengths);
11835           error (_("Out of memory allocating space for gnu histogram counts\n"));
11836           return FALSE;
11837         }
11838
11839       for (hn = 0; hn < ngnubuckets; ++hn)
11840         ++counts[lengths[hn]];
11841
11842       if (ngnubuckets > 0)
11843         {
11844           unsigned long j;
11845           printf ("      0  %-10lu (%5.1f%%)\n",
11846                   counts[0], (counts[0] * 100.0) / ngnubuckets);
11847           for (j = 1; j <= maxlength; ++j)
11848             {
11849               nzero_counts += counts[j] * j;
11850               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11851                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11852                       (nzero_counts * 100.0) / nsyms);
11853             }
11854         }
11855
11856       free (counts);
11857       free (lengths);
11858       free (gnubuckets);
11859       free (gnuchains);
11860     }
11861
11862   return TRUE;
11863 }
11864
11865 static bfd_boolean
11866 process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
11867 {
11868   unsigned int i;
11869
11870   if (dynamic_syminfo == NULL
11871       || !do_dynamic)
11872     /* No syminfo, this is ok.  */
11873     return TRUE;
11874
11875   /* There better should be a dynamic symbol section.  */
11876   if (dynamic_symbols == NULL || dynamic_strings == NULL)
11877     return FALSE;
11878
11879   if (dynamic_addr)
11880     printf (ngettext ("\nDynamic info segment at offset 0x%lx "
11881                       "contains %d entry:\n",
11882                       "\nDynamic info segment at offset 0x%lx "
11883                       "contains %d entries:\n",
11884                       dynamic_syminfo_nent),
11885             dynamic_syminfo_offset, dynamic_syminfo_nent);
11886
11887   printf (_(" Num: Name                           BoundTo     Flags\n"));
11888   for (i = 0; i < dynamic_syminfo_nent; ++i)
11889     {
11890       unsigned short int flags = dynamic_syminfo[i].si_flags;
11891
11892       printf ("%4d: ", i);
11893       if (i >= num_dynamic_syms)
11894         printf (_("<corrupt index>"));
11895       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
11896         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11897       else
11898         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
11899       putchar (' ');
11900
11901       switch (dynamic_syminfo[i].si_boundto)
11902         {
11903         case SYMINFO_BT_SELF:
11904           fputs ("SELF       ", stdout);
11905           break;
11906         case SYMINFO_BT_PARENT:
11907           fputs ("PARENT     ", stdout);
11908           break;
11909         default:
11910           if (dynamic_syminfo[i].si_boundto > 0
11911               && dynamic_syminfo[i].si_boundto < dynamic_nent
11912               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
11913             {
11914               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
11915               putchar (' ' );
11916             }
11917           else
11918             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11919           break;
11920         }
11921
11922       if (flags & SYMINFO_FLG_DIRECT)
11923         printf (" DIRECT");
11924       if (flags & SYMINFO_FLG_PASSTHRU)
11925         printf (" PASSTHRU");
11926       if (flags & SYMINFO_FLG_COPY)
11927         printf (" COPY");
11928       if (flags & SYMINFO_FLG_LAZYLOAD)
11929         printf (" LAZYLOAD");
11930
11931       puts ("");
11932     }
11933
11934   return TRUE;
11935 }
11936
11937 #define IN_RANGE(START,END,ADDR,OFF)            \
11938   (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11939
11940 /* Check to see if the given reloc needs to be handled in a target specific
11941    manner.  If so then process the reloc and return TRUE otherwise return
11942    FALSE.
11943
11944    If called with reloc == NULL, then this is a signal that reloc processing
11945    for the current section has finished, and any saved state should be
11946    discarded.  */
11947
11948 static bfd_boolean
11949 target_specific_reloc_handling (Filedata *           filedata,
11950                                 Elf_Internal_Rela *  reloc,
11951                                 unsigned char *      start,
11952                                 unsigned char *      end,
11953                                 Elf_Internal_Sym *   symtab,
11954                                 unsigned long        num_syms)
11955 {
11956   unsigned int reloc_type = 0;
11957   unsigned long sym_index = 0;
11958
11959   if (reloc)
11960     {
11961       reloc_type = get_reloc_type (filedata, reloc->r_info);
11962       sym_index = get_reloc_symindex (reloc->r_info);
11963     }
11964
11965   switch (filedata->file_header.e_machine)
11966     {
11967     case EM_MSP430:
11968     case EM_MSP430_OLD:
11969       {
11970         static Elf_Internal_Sym * saved_sym = NULL;
11971
11972         if (reloc == NULL)
11973           {
11974             saved_sym = NULL;
11975             return TRUE;
11976           }
11977
11978         switch (reloc_type)
11979           {
11980           case 10: /* R_MSP430_SYM_DIFF */
11981             if (uses_msp430x_relocs (filedata))
11982               break;
11983             /* Fall through.  */
11984           case 21: /* R_MSP430X_SYM_DIFF */
11985             /* PR 21139.  */
11986             if (sym_index >= num_syms)
11987               error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11988                      sym_index);
11989             else
11990               saved_sym = symtab + sym_index;
11991             return TRUE;
11992
11993           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11994           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11995             goto handle_sym_diff;
11996
11997           case 5: /* R_MSP430_16_BYTE */
11998           case 9: /* R_MSP430_8 */
11999             if (uses_msp430x_relocs (filedata))
12000               break;
12001             goto handle_sym_diff;
12002
12003           case 2: /* R_MSP430_ABS16 */
12004           case 15: /* R_MSP430X_ABS16 */
12005             if (! uses_msp430x_relocs (filedata))
12006               break;
12007             goto handle_sym_diff;
12008
12009           handle_sym_diff:
12010             if (saved_sym != NULL)
12011               {
12012                 int reloc_size = reloc_type == 1 ? 4 : 2;
12013                 bfd_vma value;
12014
12015                 if (sym_index >= num_syms)
12016                   error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12017                          sym_index);
12018                 else
12019                   {
12020                     value = reloc->r_addend + (symtab[sym_index].st_value
12021                                                - saved_sym->st_value);
12022
12023                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12024                       byte_put (start + reloc->r_offset, value, reloc_size);
12025                     else
12026                       /* PR 21137 */
12027                       error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12028                              (long) reloc->r_offset);
12029                   }
12030
12031                 saved_sym = NULL;
12032                 return TRUE;
12033               }
12034             break;
12035
12036           default:
12037             if (saved_sym != NULL)
12038               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12039             break;
12040           }
12041         break;
12042       }
12043
12044     case EM_MN10300:
12045     case EM_CYGNUS_MN10300:
12046       {
12047         static Elf_Internal_Sym * saved_sym = NULL;
12048
12049         if (reloc == NULL)
12050           {
12051             saved_sym = NULL;
12052             return TRUE;
12053           }
12054
12055         switch (reloc_type)
12056           {
12057           case 34: /* R_MN10300_ALIGN */
12058             return TRUE;
12059           case 33: /* R_MN10300_SYM_DIFF */
12060             if (sym_index >= num_syms)
12061               error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12062                      sym_index);
12063             else
12064               saved_sym = symtab + sym_index;
12065             return TRUE;
12066
12067           case 1: /* R_MN10300_32 */
12068           case 2: /* R_MN10300_16 */
12069             if (saved_sym != NULL)
12070               {
12071                 int reloc_size = reloc_type == 1 ? 4 : 2;
12072                 bfd_vma value;
12073
12074                 if (sym_index >= num_syms)
12075                   error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12076                          sym_index);
12077                 else
12078                   {
12079                     value = reloc->r_addend + (symtab[sym_index].st_value
12080                                                - saved_sym->st_value);
12081
12082                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12083                       byte_put (start + reloc->r_offset, value, reloc_size);
12084                     else
12085                       error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12086                              (long) reloc->r_offset);
12087                   }
12088
12089                 saved_sym = NULL;
12090                 return TRUE;
12091               }
12092             break;
12093           default:
12094             if (saved_sym != NULL)
12095               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12096             break;
12097           }
12098         break;
12099       }
12100
12101     case EM_RL78:
12102       {
12103         static bfd_vma saved_sym1 = 0;
12104         static bfd_vma saved_sym2 = 0;
12105         static bfd_vma value;
12106
12107         if (reloc == NULL)
12108           {
12109             saved_sym1 = saved_sym2 = 0;
12110             return TRUE;
12111           }
12112
12113         switch (reloc_type)
12114           {
12115           case 0x80: /* R_RL78_SYM.  */
12116             saved_sym1 = saved_sym2;
12117             if (sym_index >= num_syms)
12118               error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12119                      sym_index);
12120             else
12121               {
12122                 saved_sym2 = symtab[sym_index].st_value;
12123                 saved_sym2 += reloc->r_addend;
12124               }
12125             return TRUE;
12126
12127           case 0x83: /* R_RL78_OPsub.  */
12128             value = saved_sym1 - saved_sym2;
12129             saved_sym2 = saved_sym1 = 0;
12130             return TRUE;
12131             break;
12132
12133           case 0x41: /* R_RL78_ABS32.  */
12134             if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12135               byte_put (start + reloc->r_offset, value, 4);
12136             else
12137               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12138                      (long) reloc->r_offset);
12139             value = 0;
12140             return TRUE;
12141
12142           case 0x43: /* R_RL78_ABS16.  */
12143             if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12144               byte_put (start + reloc->r_offset, value, 2);
12145             else
12146               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12147                      (long) reloc->r_offset);
12148             value = 0;
12149             return TRUE;
12150
12151           default:
12152             break;
12153           }
12154         break;
12155       }
12156     }
12157
12158   return FALSE;
12159 }
12160
12161 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12162    DWARF debug sections.  This is a target specific test.  Note - we do not
12163    go through the whole including-target-headers-multiple-times route, (as
12164    we have already done with <elf/h8.h>) because this would become very
12165    messy and even then this function would have to contain target specific
12166    information (the names of the relocs instead of their numeric values).
12167    FIXME: This is not the correct way to solve this problem.  The proper way
12168    is to have target specific reloc sizing and typing functions created by
12169    the reloc-macros.h header, in the same way that it already creates the
12170    reloc naming functions.  */
12171
12172 static bfd_boolean
12173 is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12174 {
12175   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12176   switch (filedata->file_header.e_machine)
12177     {
12178     case EM_386:
12179     case EM_IAMCU:
12180       return reloc_type == 1; /* R_386_32.  */
12181     case EM_68K:
12182       return reloc_type == 1; /* R_68K_32.  */
12183     case EM_860:
12184       return reloc_type == 1; /* R_860_32.  */
12185     case EM_960:
12186       return reloc_type == 2; /* R_960_32.  */
12187     case EM_AARCH64:
12188       return (reloc_type == 258
12189               || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12190     case EM_ADAPTEVA_EPIPHANY:
12191       return reloc_type == 3;
12192     case EM_ALPHA:
12193       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
12194     case EM_ARC:
12195       return reloc_type == 1; /* R_ARC_32.  */
12196     case EM_ARC_COMPACT:
12197     case EM_ARC_COMPACT2:
12198       return reloc_type == 4; /* R_ARC_32.  */
12199     case EM_ARM:
12200       return reloc_type == 2; /* R_ARM_ABS32 */
12201     case EM_AVR_OLD:
12202     case EM_AVR:
12203       return reloc_type == 1;
12204     case EM_BLACKFIN:
12205       return reloc_type == 0x12; /* R_byte4_data.  */
12206     case EM_CRIS:
12207       return reloc_type == 3; /* R_CRIS_32.  */
12208     case EM_CR16:
12209       return reloc_type == 3; /* R_CR16_NUM32.  */
12210     case EM_CRX:
12211       return reloc_type == 15; /* R_CRX_NUM32.  */
12212     case EM_CYGNUS_FRV:
12213       return reloc_type == 1;
12214     case EM_CYGNUS_D10V:
12215     case EM_D10V:
12216       return reloc_type == 6; /* R_D10V_32.  */
12217     case EM_CYGNUS_D30V:
12218     case EM_D30V:
12219       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
12220     case EM_DLX:
12221       return reloc_type == 3; /* R_DLX_RELOC_32.  */
12222     case EM_CYGNUS_FR30:
12223     case EM_FR30:
12224       return reloc_type == 3; /* R_FR30_32.  */
12225     case EM_FT32:
12226       return reloc_type == 1; /* R_FT32_32.  */
12227     case EM_H8S:
12228     case EM_H8_300:
12229     case EM_H8_300H:
12230       return reloc_type == 1; /* R_H8_DIR32.  */
12231     case EM_IA_64:
12232       return (reloc_type == 0x64    /* R_IA64_SECREL32MSB.  */
12233               || reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
12234               || reloc_type == 0x24 /* R_IA64_DIR32MSB.  */
12235               || reloc_type == 0x25 /* R_IA64_DIR32LSB.  */);
12236     case EM_IP2K_OLD:
12237     case EM_IP2K:
12238       return reloc_type == 2; /* R_IP2K_32.  */
12239     case EM_IQ2000:
12240       return reloc_type == 2; /* R_IQ2000_32.  */
12241     case EM_LATTICEMICO32:
12242       return reloc_type == 3; /* R_LM32_32.  */
12243     case EM_M32C_OLD:
12244     case EM_M32C:
12245       return reloc_type == 3; /* R_M32C_32.  */
12246     case EM_M32R:
12247       return reloc_type == 34; /* R_M32R_32_RELA.  */
12248     case EM_68HC11:
12249     case EM_68HC12:
12250       return reloc_type == 6; /* R_M68HC11_32.  */
12251     case EM_MCORE:
12252       return reloc_type == 1; /* R_MCORE_ADDR32.  */
12253     case EM_CYGNUS_MEP:
12254       return reloc_type == 4; /* R_MEP_32.  */
12255     case EM_METAG:
12256       return reloc_type == 2; /* R_METAG_ADDR32.  */
12257     case EM_MICROBLAZE:
12258       return reloc_type == 1; /* R_MICROBLAZE_32.  */
12259     case EM_MIPS:
12260       return reloc_type == 2; /* R_MIPS_32.  */
12261     case EM_MMIX:
12262       return reloc_type == 4; /* R_MMIX_32.  */
12263     case EM_CYGNUS_MN10200:
12264     case EM_MN10200:
12265       return reloc_type == 1; /* R_MN10200_32.  */
12266     case EM_CYGNUS_MN10300:
12267     case EM_MN10300:
12268       return reloc_type == 1; /* R_MN10300_32.  */
12269     case EM_MOXIE:
12270       return reloc_type == 1; /* R_MOXIE_32.  */
12271     case EM_MSP430_OLD:
12272     case EM_MSP430:
12273       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
12274     case EM_MT:
12275       return reloc_type == 2; /* R_MT_32.  */
12276     case EM_NDS32:
12277       return reloc_type == 20; /* R_NDS32_RELA.  */
12278     case EM_ALTERA_NIOS2:
12279       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
12280     case EM_NIOS32:
12281       return reloc_type == 1; /* R_NIOS_32.  */
12282     case EM_OR1K:
12283       return reloc_type == 1; /* R_OR1K_32.  */
12284     case EM_PARISC:
12285       return (reloc_type == 1 /* R_PARISC_DIR32.  */
12286               || reloc_type == 41); /* R_PARISC_SECREL32.  */
12287     case EM_PJ:
12288     case EM_PJ_OLD:
12289       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
12290     case EM_PPC64:
12291       return reloc_type == 1; /* R_PPC64_ADDR32.  */
12292     case EM_PPC:
12293       return reloc_type == 1; /* R_PPC_ADDR32.  */
12294     case EM_TI_PRU:
12295       return reloc_type == 11; /* R_PRU_BFD_RELOC_32.  */
12296     case EM_RISCV:
12297       return reloc_type == 1; /* R_RISCV_32.  */
12298     case EM_RL78:
12299       return reloc_type == 1; /* R_RL78_DIR32.  */
12300     case EM_RX:
12301       return reloc_type == 1; /* R_RX_DIR32.  */
12302     case EM_S370:
12303       return reloc_type == 1; /* R_I370_ADDR31.  */
12304     case EM_S390_OLD:
12305     case EM_S390:
12306       return reloc_type == 4; /* R_S390_32.  */
12307     case EM_SCORE:
12308       return reloc_type == 8; /* R_SCORE_ABS32.  */
12309     case EM_SH:
12310       return reloc_type == 1; /* R_SH_DIR32.  */
12311     case EM_SPARC32PLUS:
12312     case EM_SPARCV9:
12313     case EM_SPARC:
12314       return reloc_type == 3 /* R_SPARC_32.  */
12315         || reloc_type == 23; /* R_SPARC_UA32.  */
12316     case EM_SPU:
12317       return reloc_type == 6; /* R_SPU_ADDR32 */
12318     case EM_TI_C6000:
12319       return reloc_type == 1; /* R_C6000_ABS32.  */
12320     case EM_TILEGX:
12321       return reloc_type == 2; /* R_TILEGX_32.  */
12322     case EM_TILEPRO:
12323       return reloc_type == 1; /* R_TILEPRO_32.  */
12324     case EM_CYGNUS_V850:
12325     case EM_V850:
12326       return reloc_type == 6; /* R_V850_ABS32.  */
12327     case EM_V800:
12328       return reloc_type == 0x33; /* R_V810_WORD.  */
12329     case EM_VAX:
12330       return reloc_type == 1; /* R_VAX_32.  */
12331     case EM_VISIUM:
12332       return reloc_type == 3;  /* R_VISIUM_32. */
12333     case EM_WEBASSEMBLY:
12334       return reloc_type == 1;  /* R_WASM32_32.  */
12335     case EM_X86_64:
12336     case EM_L1OM:
12337     case EM_K1OM:
12338       return reloc_type == 10; /* R_X86_64_32.  */
12339     case EM_XC16X:
12340     case EM_C166:
12341       return reloc_type == 3; /* R_XC16C_ABS_32.  */
12342     case EM_XGATE:
12343       return reloc_type == 4; /* R_XGATE_32.  */
12344     case EM_XSTORMY16:
12345       return reloc_type == 1; /* R_XSTROMY16_32.  */
12346     case EM_XTENSA_OLD:
12347     case EM_XTENSA:
12348       return reloc_type == 1; /* R_XTENSA_32.  */
12349     default:
12350       {
12351         static unsigned int prev_warn = 0;
12352
12353         /* Avoid repeating the same warning multiple times.  */
12354         if (prev_warn != filedata->file_header.e_machine)
12355           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12356                  filedata->file_header.e_machine);
12357         prev_warn = filedata->file_header.e_machine;
12358         return FALSE;
12359       }
12360     }
12361 }
12362
12363 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12364    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
12365
12366 static bfd_boolean
12367 is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12368 {
12369   switch (filedata->file_header.e_machine)
12370   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12371     {
12372     case EM_386:
12373     case EM_IAMCU:
12374       return reloc_type == 2;  /* R_386_PC32.  */
12375     case EM_68K:
12376       return reloc_type == 4;  /* R_68K_PC32.  */
12377     case EM_AARCH64:
12378       return reloc_type == 261; /* R_AARCH64_PREL32 */
12379     case EM_ADAPTEVA_EPIPHANY:
12380       return reloc_type == 6;
12381     case EM_ALPHA:
12382       return reloc_type == 10; /* R_ALPHA_SREL32.  */
12383     case EM_ARC_COMPACT:
12384     case EM_ARC_COMPACT2:
12385       return reloc_type == 49; /* R_ARC_32_PCREL.  */
12386     case EM_ARM:
12387       return reloc_type == 3;  /* R_ARM_REL32 */
12388     case EM_AVR_OLD:
12389     case EM_AVR:
12390       return reloc_type == 36; /* R_AVR_32_PCREL.  */
12391     case EM_MICROBLAZE:
12392       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
12393     case EM_OR1K:
12394       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
12395     case EM_PARISC:
12396       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
12397     case EM_PPC:
12398       return reloc_type == 26; /* R_PPC_REL32.  */
12399     case EM_PPC64:
12400       return reloc_type == 26; /* R_PPC64_REL32.  */
12401     case EM_S390_OLD:
12402     case EM_S390:
12403       return reloc_type == 5;  /* R_390_PC32.  */
12404     case EM_SH:
12405       return reloc_type == 2;  /* R_SH_REL32.  */
12406     case EM_SPARC32PLUS:
12407     case EM_SPARCV9:
12408     case EM_SPARC:
12409       return reloc_type == 6;  /* R_SPARC_DISP32.  */
12410     case EM_SPU:
12411       return reloc_type == 13; /* R_SPU_REL32.  */
12412     case EM_TILEGX:
12413       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
12414     case EM_TILEPRO:
12415       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
12416     case EM_VISIUM:
12417       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
12418     case EM_X86_64:
12419     case EM_L1OM:
12420     case EM_K1OM:
12421       return reloc_type == 2;  /* R_X86_64_PC32.  */
12422     case EM_XTENSA_OLD:
12423     case EM_XTENSA:
12424       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
12425     default:
12426       /* Do not abort or issue an error message here.  Not all targets use
12427          pc-relative 32-bit relocs in their DWARF debug information and we
12428          have already tested for target coverage in is_32bit_abs_reloc.  A
12429          more helpful warning message will be generated by apply_relocations
12430          anyway, so just return.  */
12431       return FALSE;
12432     }
12433 }
12434
12435 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12436    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
12437
12438 static bfd_boolean
12439 is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12440 {
12441   switch (filedata->file_header.e_machine)
12442     {
12443     case EM_AARCH64:
12444       return reloc_type == 257; /* R_AARCH64_ABS64.  */
12445     case EM_ALPHA:
12446       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
12447     case EM_IA_64:
12448       return (reloc_type == 0x26    /* R_IA64_DIR64MSB.  */
12449               || reloc_type == 0x27 /* R_IA64_DIR64LSB.  */);
12450     case EM_PARISC:
12451       return reloc_type == 80; /* R_PARISC_DIR64.  */
12452     case EM_PPC64:
12453       return reloc_type == 38; /* R_PPC64_ADDR64.  */
12454     case EM_RISCV:
12455       return reloc_type == 2; /* R_RISCV_64.  */
12456     case EM_SPARC32PLUS:
12457     case EM_SPARCV9:
12458     case EM_SPARC:
12459       return reloc_type == 32 /* R_SPARC_64.  */
12460         || reloc_type == 54; /* R_SPARC_UA64.  */
12461     case EM_X86_64:
12462     case EM_L1OM:
12463     case EM_K1OM:
12464       return reloc_type == 1; /* R_X86_64_64.  */
12465     case EM_S390_OLD:
12466     case EM_S390:
12467       return reloc_type == 22;  /* R_S390_64.  */
12468     case EM_TILEGX:
12469       return reloc_type == 1; /* R_TILEGX_64.  */
12470     case EM_MIPS:
12471       return reloc_type == 18;  /* R_MIPS_64.  */
12472     default:
12473       return FALSE;
12474     }
12475 }
12476
12477 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12478    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
12479
12480 static bfd_boolean
12481 is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12482 {
12483   switch (filedata->file_header.e_machine)
12484     {
12485     case EM_AARCH64:
12486       return reloc_type == 260; /* R_AARCH64_PREL64.  */
12487     case EM_ALPHA:
12488       return reloc_type == 11; /* R_ALPHA_SREL64.  */
12489     case EM_IA_64:
12490       return (reloc_type == 0x4e    /* R_IA64_PCREL64MSB.  */
12491               || reloc_type == 0x4f /* R_IA64_PCREL64LSB.  */);
12492     case EM_PARISC:
12493       return reloc_type == 72; /* R_PARISC_PCREL64.  */
12494     case EM_PPC64:
12495       return reloc_type == 44; /* R_PPC64_REL64.  */
12496     case EM_SPARC32PLUS:
12497     case EM_SPARCV9:
12498     case EM_SPARC:
12499       return reloc_type == 46; /* R_SPARC_DISP64.  */
12500     case EM_X86_64:
12501     case EM_L1OM:
12502     case EM_K1OM:
12503       return reloc_type == 24; /* R_X86_64_PC64.  */
12504     case EM_S390_OLD:
12505     case EM_S390:
12506       return reloc_type == 23;  /* R_S390_PC64.  */
12507     case EM_TILEGX:
12508       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
12509     default:
12510       return FALSE;
12511     }
12512 }
12513
12514 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12515    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
12516
12517 static bfd_boolean
12518 is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12519 {
12520   switch (filedata->file_header.e_machine)
12521     {
12522     case EM_CYGNUS_MN10200:
12523     case EM_MN10200:
12524       return reloc_type == 4; /* R_MN10200_24.  */
12525     case EM_FT32:
12526       return reloc_type == 5; /* R_FT32_20.  */
12527     default:
12528       return FALSE;
12529     }
12530 }
12531
12532 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12533    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
12534
12535 static bfd_boolean
12536 is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12537 {
12538   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12539   switch (filedata->file_header.e_machine)
12540     {
12541     case EM_ARC:
12542     case EM_ARC_COMPACT:
12543     case EM_ARC_COMPACT2:
12544       return reloc_type == 2; /* R_ARC_16.  */
12545     case EM_ADAPTEVA_EPIPHANY:
12546       return reloc_type == 5;
12547     case EM_AVR_OLD:
12548     case EM_AVR:
12549       return reloc_type == 4; /* R_AVR_16.  */
12550     case EM_CYGNUS_D10V:
12551     case EM_D10V:
12552       return reloc_type == 3; /* R_D10V_16.  */
12553     case EM_FT32:
12554       return reloc_type == 2; /* R_FT32_16.  */
12555     case EM_H8S:
12556     case EM_H8_300:
12557     case EM_H8_300H:
12558       return reloc_type == R_H8_DIR16;
12559     case EM_IP2K_OLD:
12560     case EM_IP2K:
12561       return reloc_type == 1; /* R_IP2K_16.  */
12562     case EM_M32C_OLD:
12563     case EM_M32C:
12564       return reloc_type == 1; /* R_M32C_16 */
12565     case EM_CYGNUS_MN10200:
12566     case EM_MN10200:
12567       return reloc_type == 2; /* R_MN10200_16.  */
12568     case EM_CYGNUS_MN10300:
12569     case EM_MN10300:
12570       return reloc_type == 2; /* R_MN10300_16.  */
12571     case EM_MSP430:
12572       if (uses_msp430x_relocs (filedata))
12573         return reloc_type == 2; /* R_MSP430_ABS16.  */
12574       /* Fall through.  */
12575     case EM_MSP430_OLD:
12576       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
12577     case EM_NDS32:
12578       return reloc_type == 19; /* R_NDS32_RELA.  */
12579     case EM_ALTERA_NIOS2:
12580       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
12581     case EM_NIOS32:
12582       return reloc_type == 9; /* R_NIOS_16.  */
12583     case EM_OR1K:
12584       return reloc_type == 2; /* R_OR1K_16.  */
12585     case EM_TI_PRU:
12586       return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
12587     case EM_TI_C6000:
12588       return reloc_type == 2; /* R_C6000_ABS16.  */
12589     case EM_VISIUM:
12590       return reloc_type == 2; /* R_VISIUM_16. */
12591     case EM_XC16X:
12592     case EM_C166:
12593       return reloc_type == 2; /* R_XC16C_ABS_16.  */
12594     case EM_XGATE:
12595       return reloc_type == 3; /* R_XGATE_16.  */
12596     default:
12597       return FALSE;
12598     }
12599 }
12600
12601 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12602    a 32-bit inplace add RELA relocation used in DWARF debug sections.  */
12603
12604 static bfd_boolean
12605 is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12606 {
12607   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12608   switch (filedata->file_header.e_machine)
12609     {
12610     case EM_RISCV:
12611       return reloc_type == 35; /* R_RISCV_ADD32.  */
12612     default:
12613       return FALSE;
12614     }
12615 }
12616
12617 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12618    a 32-bit inplace sub RELA relocation used in DWARF debug sections.  */
12619
12620 static bfd_boolean
12621 is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12622 {
12623   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12624   switch (filedata->file_header.e_machine)
12625     {
12626     case EM_RISCV:
12627       return reloc_type == 39; /* R_RISCV_SUB32.  */
12628     default:
12629       return FALSE;
12630     }
12631 }
12632
12633 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12634    a 64-bit inplace add RELA relocation used in DWARF debug sections.  */
12635
12636 static bfd_boolean
12637 is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12638 {
12639   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12640   switch (filedata->file_header.e_machine)
12641     {
12642     case EM_RISCV:
12643       return reloc_type == 36; /* R_RISCV_ADD64.  */
12644     default:
12645       return FALSE;
12646     }
12647 }
12648
12649 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12650    a 64-bit inplace sub RELA relocation used in DWARF debug sections.  */
12651
12652 static bfd_boolean
12653 is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12654 {
12655   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12656   switch (filedata->file_header.e_machine)
12657     {
12658     case EM_RISCV:
12659       return reloc_type == 40; /* R_RISCV_SUB64.  */
12660     default:
12661       return FALSE;
12662     }
12663 }
12664
12665 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12666    a 16-bit inplace add RELA relocation used in DWARF debug sections.  */
12667
12668 static bfd_boolean
12669 is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12670 {
12671   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12672   switch (filedata->file_header.e_machine)
12673     {
12674     case EM_RISCV:
12675       return reloc_type == 34; /* R_RISCV_ADD16.  */
12676     default:
12677       return FALSE;
12678     }
12679 }
12680
12681 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12682    a 16-bit inplace sub RELA relocation used in DWARF debug sections.  */
12683
12684 static bfd_boolean
12685 is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12686 {
12687   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12688   switch (filedata->file_header.e_machine)
12689     {
12690     case EM_RISCV:
12691       return reloc_type == 38; /* R_RISCV_SUB16.  */
12692     default:
12693       return FALSE;
12694     }
12695 }
12696
12697 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12698    a 8-bit inplace add RELA relocation used in DWARF debug sections.  */
12699
12700 static bfd_boolean
12701 is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12702 {
12703   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12704   switch (filedata->file_header.e_machine)
12705     {
12706     case EM_RISCV:
12707       return reloc_type == 33; /* R_RISCV_ADD8.  */
12708     default:
12709       return FALSE;
12710     }
12711 }
12712
12713 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12714    a 8-bit inplace sub RELA relocation used in DWARF debug sections.  */
12715
12716 static bfd_boolean
12717 is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12718 {
12719   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12720   switch (filedata->file_header.e_machine)
12721     {
12722     case EM_RISCV:
12723       return reloc_type == 37; /* R_RISCV_SUB8.  */
12724     default:
12725       return FALSE;
12726     }
12727 }
12728
12729 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12730    relocation entries (possibly formerly used for SHT_GROUP sections).  */
12731
12732 static bfd_boolean
12733 is_none_reloc (Filedata * filedata, unsigned int reloc_type)
12734 {
12735   switch (filedata->file_header.e_machine)
12736     {
12737     case EM_386:     /* R_386_NONE.  */
12738     case EM_68K:     /* R_68K_NONE.  */
12739     case EM_ADAPTEVA_EPIPHANY:
12740     case EM_ALPHA:   /* R_ALPHA_NONE.  */
12741     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
12742     case EM_ARC:     /* R_ARC_NONE.  */
12743     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
12744     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
12745     case EM_ARM:     /* R_ARM_NONE.  */
12746     case EM_C166:    /* R_XC16X_NONE.  */
12747     case EM_CRIS:    /* R_CRIS_NONE.  */
12748     case EM_FT32:    /* R_FT32_NONE.  */
12749     case EM_IA_64:   /* R_IA64_NONE.  */
12750     case EM_K1OM:    /* R_X86_64_NONE.  */
12751     case EM_L1OM:    /* R_X86_64_NONE.  */
12752     case EM_M32R:    /* R_M32R_NONE.  */
12753     case EM_MIPS:    /* R_MIPS_NONE.  */
12754     case EM_MN10300: /* R_MN10300_NONE.  */
12755     case EM_MOXIE:   /* R_MOXIE_NONE.  */
12756     case EM_NIOS32:  /* R_NIOS_NONE.  */
12757     case EM_OR1K:    /* R_OR1K_NONE. */
12758     case EM_PARISC:  /* R_PARISC_NONE.  */
12759     case EM_PPC64:   /* R_PPC64_NONE.  */
12760     case EM_PPC:     /* R_PPC_NONE.  */
12761     case EM_RISCV:   /* R_RISCV_NONE.  */
12762     case EM_S390:    /* R_390_NONE.  */
12763     case EM_S390_OLD:
12764     case EM_SH:      /* R_SH_NONE.  */
12765     case EM_SPARC32PLUS:
12766     case EM_SPARC:   /* R_SPARC_NONE.  */
12767     case EM_SPARCV9:
12768     case EM_TILEGX:  /* R_TILEGX_NONE.  */
12769     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
12770     case EM_TI_C6000:/* R_C6000_NONE.  */
12771     case EM_X86_64:  /* R_X86_64_NONE.  */
12772     case EM_XC16X:
12773     case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
12774       return reloc_type == 0;
12775
12776     case EM_AARCH64:
12777       return reloc_type == 0 || reloc_type == 256;
12778     case EM_AVR_OLD:
12779     case EM_AVR:
12780       return (reloc_type == 0 /* R_AVR_NONE.  */
12781               || reloc_type == 30 /* R_AVR_DIFF8.  */
12782               || reloc_type == 31 /* R_AVR_DIFF16.  */
12783               || reloc_type == 32 /* R_AVR_DIFF32.  */);
12784     case EM_METAG:
12785       return reloc_type == 3; /* R_METAG_NONE.  */
12786     case EM_NDS32:
12787       return (reloc_type == 0       /* R_XTENSA_NONE.  */
12788               || reloc_type == 204  /* R_NDS32_DIFF8.  */
12789               || reloc_type == 205  /* R_NDS32_DIFF16.  */
12790               || reloc_type == 206  /* R_NDS32_DIFF32.  */
12791               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
12792     case EM_TI_PRU:
12793       return (reloc_type == 0       /* R_PRU_NONE.  */
12794               || reloc_type == 65   /* R_PRU_DIFF8.  */
12795               || reloc_type == 66   /* R_PRU_DIFF16.  */
12796               || reloc_type == 67   /* R_PRU_DIFF32.  */);
12797     case EM_XTENSA_OLD:
12798     case EM_XTENSA:
12799       return (reloc_type == 0      /* R_XTENSA_NONE.  */
12800               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
12801               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
12802               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
12803     }
12804   return FALSE;
12805 }
12806
12807 /* Returns TRUE if there is a relocation against
12808    section NAME at OFFSET bytes.  */
12809
12810 bfd_boolean
12811 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12812 {
12813   Elf_Internal_Rela * relocs;
12814   Elf_Internal_Rela * rp;
12815
12816   if (dsec == NULL || dsec->reloc_info == NULL)
12817     return FALSE;
12818
12819   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
12820
12821   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
12822     if (rp->r_offset == offset)
12823       return TRUE;
12824
12825    return FALSE;
12826 }
12827
12828 /* Apply relocations to a section.
12829    Returns TRUE upon success, FALSE otherwise.
12830    If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12831    It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
12832    will be set to the number of relocs loaded.
12833
12834    Note: So far support has been added only for those relocations
12835    which can be found in debug sections. FIXME: Add support for
12836    more relocations ?  */
12837
12838 static bfd_boolean
12839 apply_relocations (Filedata *                 filedata,
12840                    const Elf_Internal_Shdr *  section,
12841                    unsigned char *            start,
12842                    bfd_size_type              size,
12843                    void **                    relocs_return,
12844                    unsigned long *            num_relocs_return)
12845 {
12846   Elf_Internal_Shdr * relsec;
12847   unsigned char * end = start + size;
12848   bfd_boolean res = TRUE;
12849
12850   if (relocs_return != NULL)
12851     {
12852       * (Elf_Internal_Rela **) relocs_return = NULL;
12853       * num_relocs_return = 0;
12854     }
12855
12856   if (filedata->file_header.e_type != ET_REL)
12857     /* No relocs to apply.  */
12858     return TRUE;
12859
12860   /* Find the reloc section associated with the section.  */
12861   for (relsec = filedata->section_headers;
12862        relsec < filedata->section_headers + filedata->file_header.e_shnum;
12863        ++relsec)
12864     {
12865       bfd_boolean is_rela;
12866       unsigned long num_relocs;
12867       Elf_Internal_Rela * relocs;
12868       Elf_Internal_Rela * rp;
12869       Elf_Internal_Shdr * symsec;
12870       Elf_Internal_Sym * symtab;
12871       unsigned long num_syms;
12872       Elf_Internal_Sym * sym;
12873
12874       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12875           || relsec->sh_info >= filedata->file_header.e_shnum
12876           || filedata->section_headers + relsec->sh_info != section
12877           || relsec->sh_size == 0
12878           || relsec->sh_link >= filedata->file_header.e_shnum)
12879         continue;
12880
12881       is_rela = relsec->sh_type == SHT_RELA;
12882
12883       if (is_rela)
12884         {
12885           if (!slurp_rela_relocs (filedata, relsec->sh_offset,
12886                                   relsec->sh_size, & relocs, & num_relocs))
12887             return FALSE;
12888         }
12889       else
12890         {
12891           if (!slurp_rel_relocs (filedata, relsec->sh_offset,
12892                                  relsec->sh_size, & relocs, & num_relocs))
12893             return FALSE;
12894         }
12895
12896       /* SH uses RELA but uses in place value instead of the addend field.  */
12897       if (filedata->file_header.e_machine == EM_SH)
12898         is_rela = FALSE;
12899
12900       symsec = filedata->section_headers + relsec->sh_link;
12901       if (symsec->sh_type != SHT_SYMTAB
12902           && symsec->sh_type != SHT_DYNSYM)
12903         return FALSE;
12904       symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
12905
12906       for (rp = relocs; rp < relocs + num_relocs; ++rp)
12907         {
12908           bfd_vma         addend;
12909           unsigned int    reloc_type;
12910           unsigned int    reloc_size;
12911           bfd_boolean     reloc_inplace = FALSE;
12912           bfd_boolean     reloc_subtract = FALSE;
12913           unsigned char * rloc;
12914           unsigned long   sym_index;
12915
12916           reloc_type = get_reloc_type (filedata, rp->r_info);
12917
12918           if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
12919             continue;
12920           else if (is_none_reloc (filedata, reloc_type))
12921             continue;
12922           else if (is_32bit_abs_reloc (filedata, reloc_type)
12923                    || is_32bit_pcrel_reloc (filedata, reloc_type))
12924             reloc_size = 4;
12925           else if (is_64bit_abs_reloc (filedata, reloc_type)
12926                    || is_64bit_pcrel_reloc (filedata, reloc_type))
12927             reloc_size = 8;
12928           else if (is_24bit_abs_reloc (filedata, reloc_type))
12929             reloc_size = 3;
12930           else if (is_16bit_abs_reloc (filedata, reloc_type))
12931             reloc_size = 2;
12932           else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
12933                                                                  reloc_type))
12934                    || is_32bit_inplace_add_reloc (filedata, reloc_type))
12935             {
12936               reloc_size = 4;
12937               reloc_inplace = TRUE;
12938             }
12939           else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
12940                                                                  reloc_type))
12941                    || is_64bit_inplace_add_reloc (filedata, reloc_type))
12942             {
12943               reloc_size = 8;
12944               reloc_inplace = TRUE;
12945             }
12946           else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
12947                                                                  reloc_type))
12948                    || is_16bit_inplace_add_reloc (filedata, reloc_type))
12949             {
12950               reloc_size = 2;
12951               reloc_inplace = TRUE;
12952             }
12953           else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
12954                                                                 reloc_type))
12955                    || is_8bit_inplace_add_reloc (filedata, reloc_type))
12956             {
12957               reloc_size = 1;
12958               reloc_inplace = TRUE;
12959             }
12960           else
12961             {
12962               static unsigned int prev_reloc = 0;
12963
12964               if (reloc_type != prev_reloc)
12965                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12966                       reloc_type, printable_section_name (filedata, section));
12967               prev_reloc = reloc_type;
12968               res = FALSE;
12969               continue;
12970             }
12971
12972           rloc = start + rp->r_offset;
12973           if ((rloc + reloc_size) > end || (rloc < start))
12974             {
12975               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12976                     (unsigned long) rp->r_offset,
12977                     printable_section_name (filedata, section));
12978               res = FALSE;
12979               continue;
12980             }
12981
12982           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
12983           if (sym_index >= num_syms)
12984             {
12985               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12986                     sym_index, printable_section_name (filedata, section));
12987               res = FALSE;
12988               continue;
12989             }
12990           sym = symtab + sym_index;
12991
12992           /* If the reloc has a symbol associated with it,
12993              make sure that it is of an appropriate type.
12994
12995              Relocations against symbols without type can happen.
12996              Gcc -feliminate-dwarf2-dups may generate symbols
12997              without type for debug info.
12998
12999              Icc generates relocations against function symbols
13000              instead of local labels.
13001
13002              Relocations against object symbols can happen, eg when
13003              referencing a global array.  For an example of this see
13004              the _clz.o binary in libgcc.a.  */
13005           if (sym != symtab
13006               && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13007               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13008             {
13009               warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13010                     get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13011                     printable_section_name (filedata, relsec),
13012                     (long int)(rp - relocs));
13013               res = FALSE;
13014               continue;
13015             }
13016
13017           addend = 0;
13018           if (is_rela)
13019             addend += rp->r_addend;
13020           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13021              partial_inplace.  */
13022           if (!is_rela
13023               || (filedata->file_header.e_machine == EM_XTENSA
13024                   && reloc_type == 1)
13025               || ((filedata->file_header.e_machine == EM_PJ
13026                    || filedata->file_header.e_machine == EM_PJ_OLD)
13027                   && reloc_type == 1)
13028               || ((filedata->file_header.e_machine == EM_D30V
13029                    || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13030                   && reloc_type == 12)
13031               || reloc_inplace)
13032             addend += byte_get (rloc, reloc_size);
13033
13034           if (is_32bit_pcrel_reloc (filedata, reloc_type)
13035               || is_64bit_pcrel_reloc (filedata, reloc_type))
13036             {
13037               /* On HPPA, all pc-relative relocations are biased by 8.  */
13038               if (filedata->file_header.e_machine == EM_PARISC)
13039                 addend -= 8;
13040               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13041                         reloc_size);
13042             }
13043           else if (reloc_subtract)
13044             byte_put (rloc, addend - sym->st_value, reloc_size);
13045           else
13046             byte_put (rloc, addend + sym->st_value, reloc_size);
13047         }
13048
13049       free (symtab);
13050       /* Let the target specific reloc processing code know that
13051          we have finished with these relocs.  */
13052       target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13053
13054       if (relocs_return)
13055         {
13056           * (Elf_Internal_Rela **) relocs_return = relocs;
13057           * num_relocs_return = num_relocs;
13058         }
13059       else
13060         free (relocs);
13061
13062       break;
13063     }
13064
13065   return res;
13066 }
13067
13068 #ifdef SUPPORT_DISASSEMBLY
13069 static bfd_boolean
13070 disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13071 {
13072   printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13073
13074   /* FIXME: XXX -- to be done --- XXX */
13075
13076   return TRUE;
13077 }
13078 #endif
13079
13080 /* Reads in the contents of SECTION from FILE, returning a pointer
13081    to a malloc'ed buffer or NULL if something went wrong.  */
13082
13083 static char *
13084 get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13085 {
13086   bfd_size_type num_bytes = section->sh_size;
13087
13088   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13089     {
13090       printf (_("Section '%s' has no data to dump.\n"),
13091               printable_section_name (filedata, section));
13092       return NULL;
13093     }
13094
13095   return  (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13096                              _("section contents"));
13097 }
13098
13099 /* Uncompresses a section that was compressed using zlib, in place.  */
13100
13101 static bfd_boolean
13102 uncompress_section_contents (unsigned char **   buffer,
13103                              dwarf_size_type    uncompressed_size,
13104                              dwarf_size_type *  size)
13105 {
13106   dwarf_size_type compressed_size = *size;
13107   unsigned char * compressed_buffer = *buffer;
13108   unsigned char * uncompressed_buffer;
13109   z_stream strm;
13110   int rc;
13111
13112   /* It is possible the section consists of several compressed
13113      buffers concatenated together, so we uncompress in a loop.  */
13114   /* PR 18313: The state field in the z_stream structure is supposed
13115      to be invisible to the user (ie us), but some compilers will
13116      still complain about it being used without initialisation.  So
13117      we first zero the entire z_stream structure and then set the fields
13118      that we need.  */
13119   memset (& strm, 0, sizeof strm);
13120   strm.avail_in = compressed_size;
13121   strm.next_in = (Bytef *) compressed_buffer;
13122   strm.avail_out = uncompressed_size;
13123   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13124
13125   rc = inflateInit (& strm);
13126   while (strm.avail_in > 0)
13127     {
13128       if (rc != Z_OK)
13129         goto fail;
13130       strm.next_out = ((Bytef *) uncompressed_buffer
13131                        + (uncompressed_size - strm.avail_out));
13132       rc = inflate (&strm, Z_FINISH);
13133       if (rc != Z_STREAM_END)
13134         goto fail;
13135       rc = inflateReset (& strm);
13136     }
13137   rc = inflateEnd (& strm);
13138   if (rc != Z_OK
13139       || strm.avail_out != 0)
13140     goto fail;
13141
13142   *buffer = uncompressed_buffer;
13143   *size = uncompressed_size;
13144   return TRUE;
13145
13146  fail:
13147   free (uncompressed_buffer);
13148   /* Indicate decompression failure.  */
13149   *buffer = NULL;
13150   return FALSE;
13151 }
13152
13153 static bfd_boolean
13154 dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13155 {
13156   Elf_Internal_Shdr *  relsec;
13157   bfd_size_type        num_bytes;
13158   unsigned char *      data;
13159   unsigned char *      end;
13160   unsigned char *      real_start;
13161   unsigned char *      start;
13162   bfd_boolean          some_strings_shown;
13163
13164   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13165   if (start == NULL)
13166     /* PR 21820: Do not fail if the section was empty.  */
13167     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13168
13169   num_bytes = section->sh_size;
13170
13171   printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13172
13173   if (decompress_dumps)
13174     {
13175       dwarf_size_type new_size = num_bytes;
13176       dwarf_size_type uncompressed_size = 0;
13177
13178       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13179         {
13180           Elf_Internal_Chdr chdr;
13181           unsigned int compression_header_size
13182             = get_compression_header (& chdr, (unsigned char *) start,
13183                                       num_bytes);
13184
13185           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13186             {
13187               warn (_("section '%s' has unsupported compress type: %d\n"),
13188                     printable_section_name (filedata, section), chdr.ch_type);
13189               return FALSE;
13190             }
13191           else if (chdr.ch_addralign != section->sh_addralign)
13192             {
13193               warn (_("compressed section '%s' is corrupted\n"),
13194                     printable_section_name (filedata, section));
13195               return FALSE;
13196             }
13197           uncompressed_size = chdr.ch_size;
13198           start += compression_header_size;
13199           new_size -= compression_header_size;
13200         }
13201       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13202         {
13203           /* Read the zlib header.  In this case, it should be "ZLIB"
13204              followed by the uncompressed section size, 8 bytes in
13205              big-endian order.  */
13206           uncompressed_size = start[4]; uncompressed_size <<= 8;
13207           uncompressed_size += start[5]; uncompressed_size <<= 8;
13208           uncompressed_size += start[6]; uncompressed_size <<= 8;
13209           uncompressed_size += start[7]; uncompressed_size <<= 8;
13210           uncompressed_size += start[8]; uncompressed_size <<= 8;
13211           uncompressed_size += start[9]; uncompressed_size <<= 8;
13212           uncompressed_size += start[10]; uncompressed_size <<= 8;
13213           uncompressed_size += start[11];
13214           start += 12;
13215           new_size -= 12;
13216         }
13217
13218       if (uncompressed_size)
13219         {
13220           if (uncompress_section_contents (& start,
13221                                            uncompressed_size, & new_size))
13222             num_bytes = new_size;
13223           else
13224             {
13225               error (_("Unable to decompress section %s\n"),
13226                      printable_section_name (filedata, section));
13227               return FALSE;
13228             }
13229         }
13230       else
13231         start = real_start;
13232     }
13233
13234   /* If the section being dumped has relocations against it the user might
13235      be expecting these relocations to have been applied.  Check for this
13236      case and issue a warning message in order to avoid confusion.
13237      FIXME: Maybe we ought to have an option that dumps a section with
13238      relocs applied ?  */
13239   for (relsec = filedata->section_headers;
13240        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13241        ++relsec)
13242     {
13243       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13244           || relsec->sh_info >= filedata->file_header.e_shnum
13245           || filedata->section_headers + relsec->sh_info != section
13246           || relsec->sh_size == 0
13247           || relsec->sh_link >= filedata->file_header.e_shnum)
13248         continue;
13249
13250       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13251       break;
13252     }
13253
13254   data = start;
13255   end  = start + num_bytes;
13256   some_strings_shown = FALSE;
13257
13258   while (data < end)
13259     {
13260       while (!ISPRINT (* data))
13261         if (++ data >= end)
13262           break;
13263
13264       if (data < end)
13265         {
13266           size_t maxlen = end - data;
13267
13268 #ifndef __MSVCRT__
13269           /* PR 11128: Use two separate invocations in order to work
13270              around bugs in the Solaris 8 implementation of printf.  */
13271           printf ("  [%6tx]  ", data - start);
13272 #else
13273           printf ("  [%6Ix]  ", (size_t) (data - start));
13274 #endif
13275           if (maxlen > 0)
13276             {
13277               print_symbol ((int) maxlen, (const char *) data);
13278               putchar ('\n');
13279               data += strnlen ((const char *) data, maxlen);
13280             }
13281           else
13282             {
13283               printf (_("<corrupt>\n"));
13284               data = end;
13285             }
13286           some_strings_shown = TRUE;
13287         }
13288     }
13289
13290   if (! some_strings_shown)
13291     printf (_("  No strings found in this section."));
13292
13293   free (real_start);
13294
13295   putchar ('\n');
13296   return TRUE;
13297 }
13298
13299 static bfd_boolean
13300 dump_section_as_bytes (Elf_Internal_Shdr *  section,
13301                        Filedata *           filedata,
13302                        bfd_boolean          relocate)
13303 {
13304   Elf_Internal_Shdr * relsec;
13305   bfd_size_type       bytes;
13306   bfd_size_type       section_size;
13307   bfd_vma             addr;
13308   unsigned char *     data;
13309   unsigned char *     real_start;
13310   unsigned char *     start;
13311
13312   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13313   if (start == NULL)
13314     /* PR 21820: Do not fail if the section was empty.  */
13315     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13316
13317   section_size = section->sh_size;
13318
13319   printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13320
13321   if (decompress_dumps)
13322     {
13323       dwarf_size_type new_size = section_size;
13324       dwarf_size_type uncompressed_size = 0;
13325
13326       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13327         {
13328           Elf_Internal_Chdr chdr;
13329           unsigned int compression_header_size
13330             = get_compression_header (& chdr, start, section_size);
13331
13332           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13333             {
13334               warn (_("section '%s' has unsupported compress type: %d\n"),
13335                     printable_section_name (filedata, section), chdr.ch_type);
13336               return FALSE;
13337             }
13338           else if (chdr.ch_addralign != section->sh_addralign)
13339             {
13340               warn (_("compressed section '%s' is corrupted\n"),
13341                     printable_section_name (filedata, section));
13342               return FALSE;
13343             }
13344           uncompressed_size = chdr.ch_size;
13345           start += compression_header_size;
13346           new_size -= compression_header_size;
13347         }
13348       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13349         {
13350           /* Read the zlib header.  In this case, it should be "ZLIB"
13351              followed by the uncompressed section size, 8 bytes in
13352              big-endian order.  */
13353           uncompressed_size = start[4]; uncompressed_size <<= 8;
13354           uncompressed_size += start[5]; uncompressed_size <<= 8;
13355           uncompressed_size += start[6]; uncompressed_size <<= 8;
13356           uncompressed_size += start[7]; uncompressed_size <<= 8;
13357           uncompressed_size += start[8]; uncompressed_size <<= 8;
13358           uncompressed_size += start[9]; uncompressed_size <<= 8;
13359           uncompressed_size += start[10]; uncompressed_size <<= 8;
13360           uncompressed_size += start[11];
13361           start += 12;
13362           new_size -= 12;
13363         }
13364
13365       if (uncompressed_size)
13366         {
13367           if (uncompress_section_contents (& start, uncompressed_size,
13368                                            & new_size))
13369             {
13370               section_size = new_size;
13371             }
13372           else
13373             {
13374               error (_("Unable to decompress section %s\n"),
13375                      printable_section_name (filedata, section));
13376               /* FIXME: Print the section anyway ?  */
13377               return FALSE;
13378             }
13379         }
13380       else
13381         start = real_start;
13382     }
13383
13384   if (relocate)
13385     {
13386       if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
13387         return FALSE;
13388     }
13389   else
13390     {
13391       /* If the section being dumped has relocations against it the user might
13392          be expecting these relocations to have been applied.  Check for this
13393          case and issue a warning message in order to avoid confusion.
13394          FIXME: Maybe we ought to have an option that dumps a section with
13395          relocs applied ?  */
13396       for (relsec = filedata->section_headers;
13397            relsec < filedata->section_headers + filedata->file_header.e_shnum;
13398            ++relsec)
13399         {
13400           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13401               || relsec->sh_info >= filedata->file_header.e_shnum
13402               || filedata->section_headers + relsec->sh_info != section
13403               || relsec->sh_size == 0
13404               || relsec->sh_link >= filedata->file_header.e_shnum)
13405             continue;
13406
13407           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13408           break;
13409         }
13410     }
13411
13412   addr = section->sh_addr;
13413   bytes = section_size;
13414   data = start;
13415
13416   while (bytes)
13417     {
13418       int j;
13419       int k;
13420       int lbytes;
13421
13422       lbytes = (bytes > 16 ? 16 : bytes);
13423
13424       printf ("  0x%8.8lx ", (unsigned long) addr);
13425
13426       for (j = 0; j < 16; j++)
13427         {
13428           if (j < lbytes)
13429             printf ("%2.2x", data[j]);
13430           else
13431             printf ("  ");
13432
13433           if ((j & 3) == 3)
13434             printf (" ");
13435         }
13436
13437       for (j = 0; j < lbytes; j++)
13438         {
13439           k = data[j];
13440           if (k >= ' ' && k < 0x7f)
13441             printf ("%c", k);
13442           else
13443             printf (".");
13444         }
13445
13446       putchar ('\n');
13447
13448       data  += lbytes;
13449       addr  += lbytes;
13450       bytes -= lbytes;
13451     }
13452
13453   free (real_start);
13454
13455   putchar ('\n');
13456   return TRUE;
13457 }
13458
13459 static bfd_boolean
13460 load_specific_debug_section (enum dwarf_section_display_enum  debug,
13461                              const Elf_Internal_Shdr *        sec,
13462                              void *                           data)
13463 {
13464   struct dwarf_section * section = &debug_displays [debug].section;
13465   char buf [64];
13466   Filedata * filedata = (Filedata *) data;
13467
13468   if (section->start != NULL)
13469     {
13470       /* If it is already loaded, do nothing.  */
13471       if (streq (section->filename, filedata->file_name))
13472         return TRUE;
13473       free (section->start);
13474     }
13475
13476   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13477   section->address = sec->sh_addr;
13478   section->user_data = NULL;
13479   section->filename = filedata->file_name;
13480   section->start = (unsigned char *) get_data (NULL, filedata,
13481                                                sec->sh_offset, 1,
13482                                                sec->sh_size, buf);
13483   if (section->start == NULL)
13484     section->size = 0;
13485   else
13486     {
13487       unsigned char *start = section->start;
13488       dwarf_size_type size = sec->sh_size;
13489       dwarf_size_type uncompressed_size = 0;
13490
13491       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13492         {
13493           Elf_Internal_Chdr chdr;
13494           unsigned int compression_header_size;
13495
13496           if (size < (is_32bit_elf
13497                       ? sizeof (Elf32_External_Chdr)
13498                       : sizeof (Elf64_External_Chdr)))
13499             {
13500               warn (_("compressed section %s is too small to contain a compression header"),
13501                     section->name);
13502               return FALSE;
13503             }
13504
13505           compression_header_size = get_compression_header (&chdr, start, size);
13506
13507           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13508             {
13509               warn (_("section '%s' has unsupported compress type: %d\n"),
13510                     section->name, chdr.ch_type);
13511               return FALSE;
13512             }
13513           else if (chdr.ch_addralign != sec->sh_addralign)
13514             {
13515               warn (_("compressed section '%s' is corrupted\n"),
13516                     section->name);
13517               return FALSE;
13518             }
13519           uncompressed_size = chdr.ch_size;
13520           start += compression_header_size;
13521           size -= compression_header_size;
13522         }
13523       else if (size > 12 && streq ((char *) start, "ZLIB"))
13524         {
13525           /* Read the zlib header.  In this case, it should be "ZLIB"
13526              followed by the uncompressed section size, 8 bytes in
13527              big-endian order.  */
13528           uncompressed_size = start[4]; uncompressed_size <<= 8;
13529           uncompressed_size += start[5]; uncompressed_size <<= 8;
13530           uncompressed_size += start[6]; uncompressed_size <<= 8;
13531           uncompressed_size += start[7]; uncompressed_size <<= 8;
13532           uncompressed_size += start[8]; uncompressed_size <<= 8;
13533           uncompressed_size += start[9]; uncompressed_size <<= 8;
13534           uncompressed_size += start[10]; uncompressed_size <<= 8;
13535           uncompressed_size += start[11];
13536           start += 12;
13537           size -= 12;
13538         }
13539
13540       if (uncompressed_size)
13541         {
13542           if (uncompress_section_contents (&start, uncompressed_size,
13543                                            &size))
13544             {
13545               /* Free the compressed buffer, update the section buffer
13546                  and the section size if uncompress is successful.  */
13547               free (section->start);
13548               section->start = start;
13549             }
13550           else
13551             {
13552               error (_("Unable to decompress section %s\n"),
13553                      printable_section_name (filedata, sec));
13554               return FALSE;
13555             }
13556         }
13557
13558       section->size = size;
13559     }
13560
13561   if (section->start == NULL)
13562     return FALSE;
13563
13564   if (debug_displays [debug].relocate)
13565     {
13566       if (! apply_relocations (filedata, sec, section->start, section->size,
13567                                & section->reloc_info, & section->num_relocs))
13568         return FALSE;
13569     }
13570   else
13571     {
13572       section->reloc_info = NULL;
13573       section->num_relocs = 0;
13574     }
13575
13576   return TRUE;
13577 }
13578
13579 /* If this is not NULL, load_debug_section will only look for sections
13580    within the list of sections given here.  */
13581 static unsigned int * section_subset = NULL;
13582
13583 bfd_boolean
13584 load_debug_section (enum dwarf_section_display_enum debug, void * data)
13585 {
13586   struct dwarf_section * section = &debug_displays [debug].section;
13587   Elf_Internal_Shdr * sec;
13588   Filedata * filedata = (Filedata *) data;
13589
13590   /* Without section headers we cannot find any sections.  */
13591   if (filedata->section_headers == NULL)
13592     return FALSE;
13593
13594   if (filedata->string_table == NULL
13595       && filedata->file_header.e_shstrndx != SHN_UNDEF
13596       && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
13597     {
13598       Elf_Internal_Shdr * strs;
13599
13600       /* Read in the string table, so that we have section names to scan.  */
13601       strs = filedata->section_headers + filedata->file_header.e_shstrndx;
13602
13603       if (strs != NULL && strs->sh_size != 0)
13604         {
13605           filedata->string_table
13606             = (char *) get_data (NULL, filedata, strs->sh_offset,
13607                                  1, strs->sh_size, _("string table"));
13608
13609           filedata->string_table_length
13610             = filedata->string_table != NULL ? strs->sh_size : 0;
13611         }
13612     }
13613
13614   /* Locate the debug section.  */
13615   sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
13616   if (sec != NULL)
13617     section->name = section->uncompressed_name;
13618   else
13619     {
13620       sec = find_section_in_set (filedata, section->compressed_name, section_subset);
13621       if (sec != NULL)
13622         section->name = section->compressed_name;
13623     }
13624   if (sec == NULL)
13625     return FALSE;
13626
13627   /* If we're loading from a subset of sections, and we've loaded
13628      a section matching this name before, it's likely that it's a
13629      different one.  */
13630   if (section_subset != NULL)
13631     free_debug_section (debug);
13632
13633   return load_specific_debug_section (debug, sec, data);
13634 }
13635
13636 void
13637 free_debug_section (enum dwarf_section_display_enum debug)
13638 {
13639   struct dwarf_section * section = &debug_displays [debug].section;
13640
13641   if (section->start == NULL)
13642     return;
13643
13644   free ((char *) section->start);
13645   section->start = NULL;
13646   section->address = 0;
13647   section->size = 0;
13648 }
13649
13650 static bfd_boolean
13651 display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
13652 {
13653   char * name = SECTION_NAME (section);
13654   const char * print_name = printable_section_name (filedata, section);
13655   bfd_size_type length;
13656   bfd_boolean result = TRUE;
13657   int i;
13658
13659   length = section->sh_size;
13660   if (length == 0)
13661     {
13662       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13663       return TRUE;
13664     }
13665   if (section->sh_type == SHT_NOBITS)
13666     {
13667       /* There is no point in dumping the contents of a debugging section
13668          which has the NOBITS type - the bits in the file will be random.
13669          This can happen when a file containing a .eh_frame section is
13670          stripped with the --only-keep-debug command line option.  */
13671       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13672               print_name);
13673       return FALSE;
13674     }
13675
13676   if (const_strneq (name, ".gnu.linkonce.wi."))
13677     name = ".debug_info";
13678
13679   /* See if we know how to display the contents of this section.  */
13680   for (i = 0; i < max; i++)
13681     {
13682       enum dwarf_section_display_enum  id = (enum dwarf_section_display_enum) i;
13683       struct dwarf_section_display *   display = debug_displays + i;
13684       struct dwarf_section *           sec = & display->section;
13685
13686       if (streq (sec->uncompressed_name, name)
13687           || (id == line && const_strneq (name, ".debug_line."))
13688           || streq (sec->compressed_name, name))
13689         {
13690           bfd_boolean secondary = (section != find_section (filedata, name));
13691
13692           if (secondary)
13693             free_debug_section (id);
13694
13695           if (i == line && const_strneq (name, ".debug_line."))
13696             sec->name = name;
13697           else if (streq (sec->uncompressed_name, name))
13698             sec->name = sec->uncompressed_name;
13699           else
13700             sec->name = sec->compressed_name;
13701
13702           if (load_specific_debug_section (id, section, filedata))
13703             {
13704               /* If this debug section is part of a CU/TU set in a .dwp file,
13705                  restrict load_debug_section to the sections in that set.  */
13706               section_subset = find_cu_tu_set (filedata, shndx);
13707
13708               result &= display->display (sec, filedata);
13709
13710               section_subset = NULL;
13711
13712               if (secondary || (id != info && id != abbrev))
13713                 free_debug_section (id);
13714             }
13715           break;
13716         }
13717     }
13718
13719   if (i == max)
13720     {
13721       printf (_("Unrecognized debug section: %s\n"), print_name);
13722       result = FALSE;
13723     }
13724
13725   return result;
13726 }
13727
13728 /* Set DUMP_SECTS for all sections where dumps were requested
13729    based on section name.  */
13730
13731 static void
13732 initialise_dumps_byname (Filedata * filedata)
13733 {
13734   struct dump_list_entry * cur;
13735
13736   for (cur = dump_sects_byname; cur; cur = cur->next)
13737     {
13738       unsigned int i;
13739       bfd_boolean any = FALSE;
13740
13741       for (i = 0; i < filedata->file_header.e_shnum; i++)
13742         if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
13743           {
13744             request_dump_bynumber (filedata, i, cur->type);
13745             any = TRUE;
13746           }
13747
13748       if (!any)
13749         warn (_("Section '%s' was not dumped because it does not exist!\n"),
13750               cur->name);
13751     }
13752 }
13753
13754 static bfd_boolean
13755 process_section_contents (Filedata * filedata)
13756 {
13757   Elf_Internal_Shdr * section;
13758   unsigned int i;
13759   bfd_boolean res = TRUE;
13760
13761   if (! do_dump)
13762     return TRUE;
13763
13764   initialise_dumps_byname (filedata);
13765
13766   for (i = 0, section = filedata->section_headers;
13767        i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
13768        i++, section++)
13769     {
13770       dump_type dump = filedata->dump_sects[i];
13771
13772 #ifdef SUPPORT_DISASSEMBLY
13773       if (dump & DISASS_DUMP)
13774         {
13775           if (! disassemble_section (section, filedata))
13776             res = FALSE;
13777         }
13778 #endif
13779       if (dump & HEX_DUMP)
13780         {
13781           if (! dump_section_as_bytes (section, filedata, FALSE))
13782             res = FALSE;
13783         }
13784
13785       if (dump & RELOC_DUMP)
13786         {
13787           if (! dump_section_as_bytes (section, filedata, TRUE))
13788             res = FALSE;
13789         }
13790
13791       if (dump & STRING_DUMP)
13792         {
13793           if (! dump_section_as_strings (section, filedata))
13794             res = FALSE;
13795         }
13796
13797       if (dump & DEBUG_DUMP)
13798         {
13799           if (! display_debug_section (i, section, filedata))
13800             res = FALSE;
13801         }
13802     }
13803
13804   /* Check to see if the user requested a
13805      dump of a section that does not exist.  */
13806   while (i < filedata->num_dump_sects)
13807     {
13808       if (filedata->dump_sects[i])
13809         {
13810           warn (_("Section %d was not dumped because it does not exist!\n"), i);
13811           res = FALSE;
13812         }
13813       i++;
13814     }
13815
13816   return res;
13817 }
13818
13819 static void
13820 process_mips_fpe_exception (int mask)
13821 {
13822   if (mask)
13823     {
13824       bfd_boolean first = TRUE;
13825
13826       if (mask & OEX_FPU_INEX)
13827         fputs ("INEX", stdout), first = FALSE;
13828       if (mask & OEX_FPU_UFLO)
13829         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
13830       if (mask & OEX_FPU_OFLO)
13831         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
13832       if (mask & OEX_FPU_DIV0)
13833         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
13834       if (mask & OEX_FPU_INVAL)
13835         printf ("%sINVAL", first ? "" : "|");
13836     }
13837   else
13838     fputs ("0", stdout);
13839 }
13840
13841 /* Display's the value of TAG at location P.  If TAG is
13842    greater than 0 it is assumed to be an unknown tag, and
13843    a message is printed to this effect.  Otherwise it is
13844    assumed that a message has already been printed.
13845
13846    If the bottom bit of TAG is set it assumed to have a
13847    string value, otherwise it is assumed to have an integer
13848    value.
13849
13850    Returns an updated P pointing to the first unread byte
13851    beyond the end of TAG's value.
13852
13853    Reads at or beyond END will not be made.  */
13854
13855 static unsigned char *
13856 display_tag_value (signed int tag,
13857                    unsigned char * p,
13858                    const unsigned char * const end)
13859 {
13860   unsigned long val;
13861
13862   if (tag > 0)
13863     printf ("  Tag_unknown_%d: ", tag);
13864
13865   if (p >= end)
13866     {
13867       warn (_("<corrupt tag>\n"));
13868     }
13869   else if (tag & 1)
13870     {
13871       /* PR 17531 file: 027-19978-0.004.  */
13872       size_t maxlen = (end - p) - 1;
13873
13874       putchar ('"');
13875       if (maxlen > 0)
13876         {
13877           print_symbol ((int) maxlen, (const char *) p);
13878           p += strnlen ((char *) p, maxlen) + 1;
13879         }
13880       else
13881         {
13882           printf (_("<corrupt string tag>"));
13883           p = (unsigned char *) end;
13884         }
13885       printf ("\"\n");
13886     }
13887   else
13888     {
13889       unsigned int len;
13890
13891       val = read_uleb128 (p, &len, end);
13892       p += len;
13893       printf ("%ld (0x%lx)\n", val, val);
13894     }
13895
13896   assert (p <= end);
13897   return p;
13898 }
13899
13900 /* ARC ABI attributes section.  */
13901
13902 static unsigned char *
13903 display_arc_attribute (unsigned char * p,
13904                        const unsigned char * const end)
13905 {
13906   unsigned int tag;
13907   unsigned int len;
13908   unsigned int val;
13909
13910   tag = read_uleb128 (p, &len, end);
13911   p += len;
13912
13913   switch (tag)
13914     {
13915     case Tag_ARC_PCS_config:
13916       val = read_uleb128 (p, &len, end);
13917       p += len;
13918       printf ("  Tag_ARC_PCS_config: ");
13919       switch (val)
13920         {
13921         case 0:
13922           printf (_("Absent/Non standard\n"));
13923           break;
13924         case 1:
13925           printf (_("Bare metal/mwdt\n"));
13926           break;
13927         case 2:
13928           printf (_("Bare metal/newlib\n"));
13929           break;
13930         case 3:
13931           printf (_("Linux/uclibc\n"));
13932           break;
13933         case 4:
13934           printf (_("Linux/glibc\n"));
13935           break;
13936         default:
13937           printf (_("Unknown\n"));
13938           break;
13939         }
13940       break;
13941
13942     case Tag_ARC_CPU_base:
13943       val = read_uleb128 (p, &len, end);
13944       p += len;
13945       printf ("  Tag_ARC_CPU_base: ");
13946       switch (val)
13947         {
13948         default:
13949         case TAG_CPU_NONE:
13950           printf (_("Absent\n"));
13951           break;
13952         case TAG_CPU_ARC6xx:
13953           printf ("ARC6xx\n");
13954           break;
13955         case TAG_CPU_ARC7xx:
13956           printf ("ARC7xx\n");
13957           break;
13958         case TAG_CPU_ARCEM:
13959           printf ("ARCEM\n");
13960           break;
13961         case TAG_CPU_ARCHS:
13962           printf ("ARCHS\n");
13963           break;
13964         }
13965       break;
13966
13967     case Tag_ARC_CPU_variation:
13968       val = read_uleb128 (p, &len, end);
13969       p += len;
13970       printf ("  Tag_ARC_CPU_variation: ");
13971       switch (val)
13972         {
13973         default:
13974           if (val > 0 && val < 16)
13975               printf ("Core%d\n", val);
13976           else
13977               printf ("Unknown\n");
13978           break;
13979
13980         case 0:
13981           printf (_("Absent\n"));
13982           break;
13983         }
13984       break;
13985
13986     case Tag_ARC_CPU_name:
13987       printf ("  Tag_ARC_CPU_name: ");
13988       p = display_tag_value (-1, p, end);
13989       break;
13990
13991     case Tag_ARC_ABI_rf16:
13992       val = read_uleb128 (p, &len, end);
13993       p += len;
13994       printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
13995       break;
13996
13997     case Tag_ARC_ABI_osver:
13998       val = read_uleb128 (p, &len, end);
13999       p += len;
14000       printf ("  Tag_ARC_ABI_osver: v%d\n", val);
14001       break;
14002
14003     case Tag_ARC_ABI_pic:
14004     case Tag_ARC_ABI_sda:
14005       val = read_uleb128 (p, &len, end);
14006       p += len;
14007       printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
14008               : "  Tag_ARC_ABI_pic: ");
14009       switch (val)
14010         {
14011         case 0:
14012           printf (_("Absent\n"));
14013           break;
14014         case 1:
14015           printf ("MWDT\n");
14016           break;
14017         case 2:
14018           printf ("GNU\n");
14019           break;
14020         default:
14021           printf (_("Unknown\n"));
14022           break;
14023         }
14024       break;
14025
14026     case Tag_ARC_ABI_tls:
14027       val = read_uleb128 (p, &len, end);
14028       p += len;
14029       printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14030       break;
14031
14032     case Tag_ARC_ABI_enumsize:
14033       val = read_uleb128 (p, &len, end);
14034       p += len;
14035       printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14036               _("smallest"));
14037       break;
14038
14039     case Tag_ARC_ABI_exceptions:
14040       val = read_uleb128 (p, &len, end);
14041       p += len;
14042       printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14043               : _("default"));
14044       break;
14045
14046     case Tag_ARC_ABI_double_size:
14047       val = read_uleb128 (p, &len, end);
14048       p += len;
14049       printf ("  Tag_ARC_ABI_double_size: %d\n", val);
14050       break;
14051
14052     case Tag_ARC_ISA_config:
14053       printf ("  Tag_ARC_ISA_config: ");
14054       p = display_tag_value (-1, p, end);
14055       break;
14056
14057     case Tag_ARC_ISA_apex:
14058       printf ("  Tag_ARC_ISA_apex: ");
14059       p = display_tag_value (-1, p, end);
14060       break;
14061
14062     case Tag_ARC_ISA_mpy_option:
14063       val = read_uleb128 (p, &len, end);
14064       p += len;
14065       printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
14066       break;
14067
14068     default:
14069       return display_tag_value (tag & 1, p, end);
14070     }
14071
14072   return p;
14073 }
14074
14075 /* ARM EABI attributes section.  */
14076 typedef struct
14077 {
14078   unsigned int tag;
14079   const char * name;
14080   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
14081   unsigned int type;
14082   const char ** table;
14083 } arm_attr_public_tag;
14084
14085 static const char * arm_attr_tag_CPU_arch[] =
14086   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14087    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14088    "v8-M.mainline"};
14089 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14090 static const char * arm_attr_tag_THUMB_ISA_use[] =
14091   {"No", "Thumb-1", "Thumb-2", "Yes"};
14092 static const char * arm_attr_tag_FP_arch[] =
14093   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14094    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14095 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14096 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14097   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14098    "NEON for ARMv8.1"};
14099 static const char * arm_attr_tag_PCS_config[] =
14100   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14101    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14102 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14103   {"V6", "SB", "TLS", "Unused"};
14104 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14105   {"Absolute", "PC-relative", "SB-relative", "None"};
14106 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14107   {"Absolute", "PC-relative", "None"};
14108 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14109   {"None", "direct", "GOT-indirect"};
14110 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14111   {"None", "??? 1", "2", "??? 3", "4"};
14112 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14113 static const char * arm_attr_tag_ABI_FP_denormal[] =
14114   {"Unused", "Needed", "Sign only"};
14115 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14116 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14117 static const char * arm_attr_tag_ABI_FP_number_model[] =
14118   {"Unused", "Finite", "RTABI", "IEEE 754"};
14119 static const char * arm_attr_tag_ABI_enum_size[] =
14120   {"Unused", "small", "int", "forced to int"};
14121 static const char * arm_attr_tag_ABI_HardFP_use[] =
14122   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14123 static const char * arm_attr_tag_ABI_VFP_args[] =
14124   {"AAPCS", "VFP registers", "custom", "compatible"};
14125 static const char * arm_attr_tag_ABI_WMMX_args[] =
14126   {"AAPCS", "WMMX registers", "custom"};
14127 static const char * arm_attr_tag_ABI_optimization_goals[] =
14128   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14129     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14130 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14131   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14132     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14133 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14134 static const char * arm_attr_tag_FP_HP_extension[] =
14135   {"Not Allowed", "Allowed"};
14136 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14137   {"None", "IEEE 754", "Alternative Format"};
14138 static const char * arm_attr_tag_DSP_extension[] =
14139   {"Follow architecture", "Allowed"};
14140 static const char * arm_attr_tag_MPextension_use[] =
14141   {"Not Allowed", "Allowed"};
14142 static const char * arm_attr_tag_DIV_use[] =
14143   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14144     "Allowed in v7-A with integer division extension"};
14145 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14146 static const char * arm_attr_tag_Virtualization_use[] =
14147   {"Not Allowed", "TrustZone", "Virtualization Extensions",
14148     "TrustZone and Virtualization Extensions"};
14149 static const char * arm_attr_tag_MPextension_use_legacy[] =
14150   {"Not Allowed", "Allowed"};
14151
14152 #define LOOKUP(id, name) \
14153   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14154 static arm_attr_public_tag arm_attr_public_tags[] =
14155 {
14156   {4, "CPU_raw_name", 1, NULL},
14157   {5, "CPU_name", 1, NULL},
14158   LOOKUP(6, CPU_arch),
14159   {7, "CPU_arch_profile", 0, NULL},
14160   LOOKUP(8, ARM_ISA_use),
14161   LOOKUP(9, THUMB_ISA_use),
14162   LOOKUP(10, FP_arch),
14163   LOOKUP(11, WMMX_arch),
14164   LOOKUP(12, Advanced_SIMD_arch),
14165   LOOKUP(13, PCS_config),
14166   LOOKUP(14, ABI_PCS_R9_use),
14167   LOOKUP(15, ABI_PCS_RW_data),
14168   LOOKUP(16, ABI_PCS_RO_data),
14169   LOOKUP(17, ABI_PCS_GOT_use),
14170   LOOKUP(18, ABI_PCS_wchar_t),
14171   LOOKUP(19, ABI_FP_rounding),
14172   LOOKUP(20, ABI_FP_denormal),
14173   LOOKUP(21, ABI_FP_exceptions),
14174   LOOKUP(22, ABI_FP_user_exceptions),
14175   LOOKUP(23, ABI_FP_number_model),
14176   {24, "ABI_align_needed", 0, NULL},
14177   {25, "ABI_align_preserved", 0, NULL},
14178   LOOKUP(26, ABI_enum_size),
14179   LOOKUP(27, ABI_HardFP_use),
14180   LOOKUP(28, ABI_VFP_args),
14181   LOOKUP(29, ABI_WMMX_args),
14182   LOOKUP(30, ABI_optimization_goals),
14183   LOOKUP(31, ABI_FP_optimization_goals),
14184   {32, "compatibility", 0, NULL},
14185   LOOKUP(34, CPU_unaligned_access),
14186   LOOKUP(36, FP_HP_extension),
14187   LOOKUP(38, ABI_FP_16bit_format),
14188   LOOKUP(42, MPextension_use),
14189   LOOKUP(44, DIV_use),
14190   LOOKUP(46, DSP_extension),
14191   {64, "nodefaults", 0, NULL},
14192   {65, "also_compatible_with", 0, NULL},
14193   LOOKUP(66, T2EE_use),
14194   {67, "conformance", 1, NULL},
14195   LOOKUP(68, Virtualization_use),
14196   LOOKUP(70, MPextension_use_legacy)
14197 };
14198 #undef LOOKUP
14199
14200 static unsigned char *
14201 display_arm_attribute (unsigned char * p,
14202                        const unsigned char * const end)
14203 {
14204   unsigned int tag;
14205   unsigned int len;
14206   unsigned int val;
14207   arm_attr_public_tag * attr;
14208   unsigned i;
14209   unsigned int type;
14210
14211   tag = read_uleb128 (p, &len, end);
14212   p += len;
14213   attr = NULL;
14214   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14215     {
14216       if (arm_attr_public_tags[i].tag == tag)
14217         {
14218           attr = &arm_attr_public_tags[i];
14219           break;
14220         }
14221     }
14222
14223   if (attr)
14224     {
14225       printf ("  Tag_%s: ", attr->name);
14226       switch (attr->type)
14227         {
14228         case 0:
14229           switch (tag)
14230             {
14231             case 7: /* Tag_CPU_arch_profile.  */
14232               val = read_uleb128 (p, &len, end);
14233               p += len;
14234               switch (val)
14235                 {
14236                 case 0: printf (_("None\n")); break;
14237                 case 'A': printf (_("Application\n")); break;
14238                 case 'R': printf (_("Realtime\n")); break;
14239                 case 'M': printf (_("Microcontroller\n")); break;
14240                 case 'S': printf (_("Application or Realtime\n")); break;
14241                 default: printf ("??? (%d)\n", val); break;
14242                 }
14243               break;
14244
14245             case 24: /* Tag_align_needed.  */
14246               val = read_uleb128 (p, &len, end);
14247               p += len;
14248               switch (val)
14249                 {
14250                 case 0: printf (_("None\n")); break;
14251                 case 1: printf (_("8-byte\n")); break;
14252                 case 2: printf (_("4-byte\n")); break;
14253                 case 3: printf ("??? 3\n"); break;
14254                 default:
14255                   if (val <= 12)
14256                     printf (_("8-byte and up to %d-byte extended\n"),
14257                             1 << val);
14258                   else
14259                     printf ("??? (%d)\n", val);
14260                   break;
14261                 }
14262               break;
14263
14264             case 25: /* Tag_align_preserved.  */
14265               val = read_uleb128 (p, &len, end);
14266               p += len;
14267               switch (val)
14268                 {
14269                 case 0: printf (_("None\n")); break;
14270                 case 1: printf (_("8-byte, except leaf SP\n")); break;
14271                 case 2: printf (_("8-byte\n")); break;
14272                 case 3: printf ("??? 3\n"); break;
14273                 default:
14274                   if (val <= 12)
14275                     printf (_("8-byte and up to %d-byte extended\n"),
14276                             1 << val);
14277                   else
14278                     printf ("??? (%d)\n", val);
14279                   break;
14280                 }
14281               break;
14282
14283             case 32: /* Tag_compatibility.  */
14284               {
14285                 val = read_uleb128 (p, &len, end);
14286                 p += len;
14287                 printf (_("flag = %d, vendor = "), val);
14288                 if (p < end - 1)
14289                   {
14290                     size_t maxlen = (end - p) - 1;
14291
14292                     print_symbol ((int) maxlen, (const char *) p);
14293                     p += strnlen ((char *) p, maxlen) + 1;
14294                   }
14295                 else
14296                   {
14297                     printf (_("<corrupt>"));
14298                     p = (unsigned char *) end;
14299                   }
14300                 putchar ('\n');
14301               }
14302               break;
14303
14304             case 64: /* Tag_nodefaults.  */
14305               /* PR 17531: file: 001-505008-0.01.  */
14306               if (p < end)
14307                 p++;
14308               printf (_("True\n"));
14309               break;
14310
14311             case 65: /* Tag_also_compatible_with.  */
14312               val = read_uleb128 (p, &len, end);
14313               p += len;
14314               if (val == 6 /* Tag_CPU_arch.  */)
14315                 {
14316                   val = read_uleb128 (p, &len, end);
14317                   p += len;
14318                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14319                     printf ("??? (%d)\n", val);
14320                   else
14321                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14322                 }
14323               else
14324                 printf ("???\n");
14325               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
14326                 ;
14327               break;
14328
14329             default:
14330               printf (_("<unknown: %d>\n"), tag);
14331               break;
14332             }
14333           return p;
14334
14335         case 1:
14336           return display_tag_value (-1, p, end);
14337         case 2:
14338           return display_tag_value (0, p, end);
14339
14340         default:
14341           assert (attr->type & 0x80);
14342           val = read_uleb128 (p, &len, end);
14343           p += len;
14344           type = attr->type & 0x7f;
14345           if (val >= type)
14346             printf ("??? (%d)\n", val);
14347           else
14348             printf ("%s\n", attr->table[val]);
14349           return p;
14350         }
14351     }
14352
14353   return display_tag_value (tag, p, end);
14354 }
14355
14356 static unsigned char *
14357 display_gnu_attribute (unsigned char * p,
14358                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14359                        const unsigned char * const end)
14360 {
14361   int tag;
14362   unsigned int len;
14363   unsigned int val;
14364
14365   tag = read_uleb128 (p, &len, end);
14366   p += len;
14367
14368   /* Tag_compatibility is the only generic GNU attribute defined at
14369      present.  */
14370   if (tag == 32)
14371     {
14372       val = read_uleb128 (p, &len, end);
14373       p += len;
14374
14375       printf (_("flag = %d, vendor = "), val);
14376       if (p == end)
14377         {
14378           printf (_("<corrupt>\n"));
14379           warn (_("corrupt vendor attribute\n"));
14380         }
14381       else
14382         {
14383           if (p < end - 1)
14384             {
14385               size_t maxlen = (end - p) - 1;
14386
14387               print_symbol ((int) maxlen, (const char *) p);
14388               p += strnlen ((char *) p, maxlen) + 1;
14389             }
14390           else
14391             {
14392               printf (_("<corrupt>"));
14393               p = (unsigned char *) end;
14394             }
14395           putchar ('\n');
14396         }
14397       return p;
14398     }
14399
14400   if ((tag & 2) == 0 && display_proc_gnu_attribute)
14401     return display_proc_gnu_attribute (p, tag, end);
14402
14403   return display_tag_value (tag, p, end);
14404 }
14405
14406 static unsigned char *
14407 display_power_gnu_attribute (unsigned char * p,
14408                              unsigned int tag,
14409                              const unsigned char * const end)
14410 {
14411   unsigned int len;
14412   unsigned int val;
14413
14414   if (tag == Tag_GNU_Power_ABI_FP)
14415     {
14416       val = read_uleb128 (p, &len, end);
14417       p += len;
14418       printf ("  Tag_GNU_Power_ABI_FP: ");
14419       if (len == 0)
14420         {
14421           printf (_("<corrupt>\n"));
14422           return p;
14423         }
14424
14425       if (val > 15)
14426         printf ("(%#x), ", val);
14427
14428       switch (val & 3)
14429         {
14430         case 0:
14431           printf (_("unspecified hard/soft float, "));
14432           break;
14433         case 1:
14434           printf (_("hard float, "));
14435           break;
14436         case 2:
14437           printf (_("soft float, "));
14438           break;
14439         case 3:
14440           printf (_("single-precision hard float, "));
14441           break;
14442         }
14443
14444       switch (val & 0xC)
14445         {
14446         case 0:
14447           printf (_("unspecified long double\n"));
14448           break;
14449         case 4:
14450           printf (_("128-bit IBM long double\n"));
14451           break;
14452         case 8:
14453           printf (_("64-bit long double\n"));
14454           break;
14455         case 12:
14456           printf (_("128-bit IEEE long double\n"));
14457           break;
14458         }
14459       return p;
14460     }
14461
14462   if (tag == Tag_GNU_Power_ABI_Vector)
14463     {
14464       val = read_uleb128 (p, &len, end);
14465       p += len;
14466       printf ("  Tag_GNU_Power_ABI_Vector: ");
14467       if (len == 0)
14468         {
14469           printf (_("<corrupt>\n"));
14470           return p;
14471         }
14472
14473       if (val > 3)
14474         printf ("(%#x), ", val);
14475
14476       switch (val & 3)
14477         {
14478         case 0:
14479           printf (_("unspecified\n"));
14480           break;
14481         case 1:
14482           printf (_("generic\n"));
14483           break;
14484         case 2:
14485           printf ("AltiVec\n");
14486           break;
14487         case 3:
14488           printf ("SPE\n");
14489           break;
14490         }
14491       return p;
14492     }
14493
14494   if (tag == Tag_GNU_Power_ABI_Struct_Return)
14495     {
14496       val = read_uleb128 (p, &len, end);
14497       p += len;
14498       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
14499       if (len == 0)
14500         {
14501           printf (_("<corrupt>\n"));
14502           return p;
14503         }
14504
14505       if (val > 2)
14506         printf ("(%#x), ", val);
14507
14508       switch (val & 3)
14509         {
14510         case 0:
14511           printf (_("unspecified\n"));
14512           break;
14513         case 1:
14514           printf ("r3/r4\n");
14515           break;
14516         case 2:
14517           printf (_("memory\n"));
14518           break;
14519         case 3:
14520           printf ("???\n");
14521           break;
14522         }
14523       return p;
14524     }
14525
14526   return display_tag_value (tag & 1, p, end);
14527 }
14528
14529 static unsigned char *
14530 display_s390_gnu_attribute (unsigned char * p,
14531                             unsigned int tag,
14532                             const unsigned char * const end)
14533 {
14534   unsigned int len;
14535   int val;
14536
14537   if (tag == Tag_GNU_S390_ABI_Vector)
14538     {
14539       val = read_uleb128 (p, &len, end);
14540       p += len;
14541       printf ("  Tag_GNU_S390_ABI_Vector: ");
14542
14543       switch (val)
14544         {
14545         case 0:
14546           printf (_("any\n"));
14547           break;
14548         case 1:
14549           printf (_("software\n"));
14550           break;
14551         case 2:
14552           printf (_("hardware\n"));
14553           break;
14554         default:
14555           printf ("??? (%d)\n", val);
14556           break;
14557         }
14558       return p;
14559    }
14560
14561   return display_tag_value (tag & 1, p, end);
14562 }
14563
14564 static void
14565 display_sparc_hwcaps (unsigned int mask)
14566 {
14567   if (mask)
14568     {
14569       bfd_boolean first = TRUE;
14570
14571       if (mask & ELF_SPARC_HWCAP_MUL32)
14572         fputs ("mul32", stdout), first = FALSE;
14573       if (mask & ELF_SPARC_HWCAP_DIV32)
14574         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14575       if (mask & ELF_SPARC_HWCAP_FSMULD)
14576         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14577       if (mask & ELF_SPARC_HWCAP_V8PLUS)
14578         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14579       if (mask & ELF_SPARC_HWCAP_POPC)
14580         printf ("%spopc", first ? "" : "|"), first = FALSE;
14581       if (mask & ELF_SPARC_HWCAP_VIS)
14582         printf ("%svis", first ? "" : "|"), first = FALSE;
14583       if (mask & ELF_SPARC_HWCAP_VIS2)
14584         printf ("%svis2", first ? "" : "|"), first = FALSE;
14585       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14586         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14587       if (mask & ELF_SPARC_HWCAP_FMAF)
14588         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14589       if (mask & ELF_SPARC_HWCAP_VIS3)
14590         printf ("%svis3", first ? "" : "|"), first = FALSE;
14591       if (mask & ELF_SPARC_HWCAP_HPC)
14592         printf ("%shpc", first ? "" : "|"), first = FALSE;
14593       if (mask & ELF_SPARC_HWCAP_RANDOM)
14594         printf ("%srandom", first ? "" : "|"), first = FALSE;
14595       if (mask & ELF_SPARC_HWCAP_TRANS)
14596         printf ("%strans", first ? "" : "|"), first = FALSE;
14597       if (mask & ELF_SPARC_HWCAP_FJFMAU)
14598         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14599       if (mask & ELF_SPARC_HWCAP_IMA)
14600         printf ("%sima", first ? "" : "|"), first = FALSE;
14601       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14602         printf ("%scspare", first ? "" : "|"), first = FALSE;
14603     }
14604   else
14605     fputc ('0', stdout);
14606   fputc ('\n', stdout);
14607 }
14608
14609 static void
14610 display_sparc_hwcaps2 (unsigned int mask)
14611 {
14612   if (mask)
14613     {
14614       bfd_boolean first = TRUE;
14615
14616       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14617         fputs ("fjathplus", stdout), first = FALSE;
14618       if (mask & ELF_SPARC_HWCAP2_VIS3B)
14619         printf ("%svis3b", first ? "" : "|"), first = FALSE;
14620       if (mask & ELF_SPARC_HWCAP2_ADP)
14621         printf ("%sadp", first ? "" : "|"), first = FALSE;
14622       if (mask & ELF_SPARC_HWCAP2_SPARC5)
14623         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14624       if (mask & ELF_SPARC_HWCAP2_MWAIT)
14625         printf ("%smwait", first ? "" : "|"), first = FALSE;
14626       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14627         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14628       if (mask & ELF_SPARC_HWCAP2_XMONT)
14629         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14630       if (mask & ELF_SPARC_HWCAP2_NSEC)
14631         printf ("%snsec", first ? "" : "|"), first = FALSE;
14632       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14633         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14634       if (mask & ELF_SPARC_HWCAP2_FJDES)
14635         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14636       if (mask & ELF_SPARC_HWCAP2_FJAES)
14637         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14638     }
14639   else
14640     fputc ('0', stdout);
14641   fputc ('\n', stdout);
14642 }
14643
14644 static unsigned char *
14645 display_sparc_gnu_attribute (unsigned char * p,
14646                              unsigned int tag,
14647                              const unsigned char * const end)
14648 {
14649   unsigned int len;
14650   int val;
14651
14652   if (tag == Tag_GNU_Sparc_HWCAPS)
14653     {
14654       val = read_uleb128 (p, &len, end);
14655       p += len;
14656       printf ("  Tag_GNU_Sparc_HWCAPS: ");
14657       display_sparc_hwcaps (val);
14658       return p;
14659     }
14660   if (tag == Tag_GNU_Sparc_HWCAPS2)
14661     {
14662       val = read_uleb128 (p, &len, end);
14663       p += len;
14664       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
14665       display_sparc_hwcaps2 (val);
14666       return p;
14667     }
14668
14669   return display_tag_value (tag, p, end);
14670 }
14671
14672 static void
14673 print_mips_fp_abi_value (unsigned int val)
14674 {
14675   switch (val)
14676     {
14677     case Val_GNU_MIPS_ABI_FP_ANY:
14678       printf (_("Hard or soft float\n"));
14679       break;
14680     case Val_GNU_MIPS_ABI_FP_DOUBLE:
14681       printf (_("Hard float (double precision)\n"));
14682       break;
14683     case Val_GNU_MIPS_ABI_FP_SINGLE:
14684       printf (_("Hard float (single precision)\n"));
14685       break;
14686     case Val_GNU_MIPS_ABI_FP_SOFT:
14687       printf (_("Soft float\n"));
14688       break;
14689     case Val_GNU_MIPS_ABI_FP_OLD_64:
14690       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14691       break;
14692     case Val_GNU_MIPS_ABI_FP_XX:
14693       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14694       break;
14695     case Val_GNU_MIPS_ABI_FP_64:
14696       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14697       break;
14698     case Val_GNU_MIPS_ABI_FP_64A:
14699       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14700       break;
14701     case Val_GNU_MIPS_ABI_FP_NAN2008:
14702       printf (_("NaN 2008 compatibility\n"));
14703       break;
14704     default:
14705       printf ("??? (%d)\n", val);
14706       break;
14707     }
14708 }
14709
14710 static unsigned char *
14711 display_mips_gnu_attribute (unsigned char * p,
14712                             unsigned int tag,
14713                             const unsigned char * const end)
14714 {
14715   if (tag == Tag_GNU_MIPS_ABI_FP)
14716     {
14717       unsigned int len;
14718       unsigned int val;
14719
14720       val = read_uleb128 (p, &len, end);
14721       p += len;
14722       printf ("  Tag_GNU_MIPS_ABI_FP: ");
14723
14724       print_mips_fp_abi_value (val);
14725
14726       return p;
14727    }
14728
14729   if (tag == Tag_GNU_MIPS_ABI_MSA)
14730     {
14731       unsigned int len;
14732       unsigned int val;
14733
14734       val = read_uleb128 (p, &len, end);
14735       p += len;
14736       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
14737
14738       switch (val)
14739         {
14740         case Val_GNU_MIPS_ABI_MSA_ANY:
14741           printf (_("Any MSA or not\n"));
14742           break;
14743         case Val_GNU_MIPS_ABI_MSA_128:
14744           printf (_("128-bit MSA\n"));
14745           break;
14746         default:
14747           printf ("??? (%d)\n", val);
14748           break;
14749         }
14750       return p;
14751     }
14752
14753   return display_tag_value (tag & 1, p, end);
14754 }
14755
14756 static unsigned char *
14757 display_tic6x_attribute (unsigned char * p,
14758                          const unsigned char * const end)
14759 {
14760   unsigned int tag;
14761   unsigned int len;
14762   int val;
14763
14764   tag = read_uleb128 (p, &len, end);
14765   p += len;
14766
14767   switch (tag)
14768     {
14769     case Tag_ISA:
14770       val = read_uleb128 (p, &len, end);
14771       p += len;
14772       printf ("  Tag_ISA: ");
14773
14774       switch (val)
14775         {
14776         case C6XABI_Tag_ISA_none:
14777           printf (_("None\n"));
14778           break;
14779         case C6XABI_Tag_ISA_C62X:
14780           printf ("C62x\n");
14781           break;
14782         case C6XABI_Tag_ISA_C67X:
14783           printf ("C67x\n");
14784           break;
14785         case C6XABI_Tag_ISA_C67XP:
14786           printf ("C67x+\n");
14787           break;
14788         case C6XABI_Tag_ISA_C64X:
14789           printf ("C64x\n");
14790           break;
14791         case C6XABI_Tag_ISA_C64XP:
14792           printf ("C64x+\n");
14793           break;
14794         case C6XABI_Tag_ISA_C674X:
14795           printf ("C674x\n");
14796           break;
14797         default:
14798           printf ("??? (%d)\n", val);
14799           break;
14800         }
14801       return p;
14802
14803     case Tag_ABI_wchar_t:
14804       val = read_uleb128 (p, &len, end);
14805       p += len;
14806       printf ("  Tag_ABI_wchar_t: ");
14807       switch (val)
14808         {
14809         case 0:
14810           printf (_("Not used\n"));
14811           break;
14812         case 1:
14813           printf (_("2 bytes\n"));
14814           break;
14815         case 2:
14816           printf (_("4 bytes\n"));
14817           break;
14818         default:
14819           printf ("??? (%d)\n", val);
14820           break;
14821         }
14822       return p;
14823
14824     case Tag_ABI_stack_align_needed:
14825       val = read_uleb128 (p, &len, end);
14826       p += len;
14827       printf ("  Tag_ABI_stack_align_needed: ");
14828       switch (val)
14829         {
14830         case 0:
14831           printf (_("8-byte\n"));
14832           break;
14833         case 1:
14834           printf (_("16-byte\n"));
14835           break;
14836         default:
14837           printf ("??? (%d)\n", val);
14838           break;
14839         }
14840       return p;
14841
14842     case Tag_ABI_stack_align_preserved:
14843       val = read_uleb128 (p, &len, end);
14844       p += len;
14845       printf ("  Tag_ABI_stack_align_preserved: ");
14846       switch (val)
14847         {
14848         case 0:
14849           printf (_("8-byte\n"));
14850           break;
14851         case 1:
14852           printf (_("16-byte\n"));
14853           break;
14854         default:
14855           printf ("??? (%d)\n", val);
14856           break;
14857         }
14858       return p;
14859
14860     case Tag_ABI_DSBT:
14861       val = read_uleb128 (p, &len, end);
14862       p += len;
14863       printf ("  Tag_ABI_DSBT: ");
14864       switch (val)
14865         {
14866         case 0:
14867           printf (_("DSBT addressing not used\n"));
14868           break;
14869         case 1:
14870           printf (_("DSBT addressing used\n"));
14871           break;
14872         default:
14873           printf ("??? (%d)\n", val);
14874           break;
14875         }
14876       return p;
14877
14878     case Tag_ABI_PID:
14879       val = read_uleb128 (p, &len, end);
14880       p += len;
14881       printf ("  Tag_ABI_PID: ");
14882       switch (val)
14883         {
14884         case 0:
14885           printf (_("Data addressing position-dependent\n"));
14886           break;
14887         case 1:
14888           printf (_("Data addressing position-independent, GOT near DP\n"));
14889           break;
14890         case 2:
14891           printf (_("Data addressing position-independent, GOT far from DP\n"));
14892           break;
14893         default:
14894           printf ("??? (%d)\n", val);
14895           break;
14896         }
14897       return p;
14898
14899     case Tag_ABI_PIC:
14900       val = read_uleb128 (p, &len, end);
14901       p += len;
14902       printf ("  Tag_ABI_PIC: ");
14903       switch (val)
14904         {
14905         case 0:
14906           printf (_("Code addressing position-dependent\n"));
14907           break;
14908         case 1:
14909           printf (_("Code addressing position-independent\n"));
14910           break;
14911         default:
14912           printf ("??? (%d)\n", val);
14913           break;
14914         }
14915       return p;
14916
14917     case Tag_ABI_array_object_alignment:
14918       val = read_uleb128 (p, &len, end);
14919       p += len;
14920       printf ("  Tag_ABI_array_object_alignment: ");
14921       switch (val)
14922         {
14923         case 0:
14924           printf (_("8-byte\n"));
14925           break;
14926         case 1:
14927           printf (_("4-byte\n"));
14928           break;
14929         case 2:
14930           printf (_("16-byte\n"));
14931           break;
14932         default:
14933           printf ("??? (%d)\n", val);
14934           break;
14935         }
14936       return p;
14937
14938     case Tag_ABI_array_object_align_expected:
14939       val = read_uleb128 (p, &len, end);
14940       p += len;
14941       printf ("  Tag_ABI_array_object_align_expected: ");
14942       switch (val)
14943         {
14944         case 0:
14945           printf (_("8-byte\n"));
14946           break;
14947         case 1:
14948           printf (_("4-byte\n"));
14949           break;
14950         case 2:
14951           printf (_("16-byte\n"));
14952           break;
14953         default:
14954           printf ("??? (%d)\n", val);
14955           break;
14956         }
14957       return p;
14958
14959     case Tag_ABI_compatibility:
14960       {
14961         val = read_uleb128 (p, &len, end);
14962         p += len;
14963         printf ("  Tag_ABI_compatibility: ");
14964         printf (_("flag = %d, vendor = "), val);
14965         if (p < end - 1)
14966           {
14967             size_t maxlen = (end - p) - 1;
14968
14969             print_symbol ((int) maxlen, (const char *) p);
14970             p += strnlen ((char *) p, maxlen) + 1;
14971           }
14972         else
14973           {
14974             printf (_("<corrupt>"));
14975             p = (unsigned char *) end;
14976           }
14977         putchar ('\n');
14978         return p;
14979       }
14980
14981     case Tag_ABI_conformance:
14982       {
14983         printf ("  Tag_ABI_conformance: \"");
14984         if (p < end - 1)
14985           {
14986             size_t maxlen = (end - p) - 1;
14987
14988             print_symbol ((int) maxlen, (const char *) p);
14989             p += strnlen ((char *) p, maxlen) + 1;
14990           }
14991         else
14992           {
14993             printf (_("<corrupt>"));
14994             p = (unsigned char *) end;
14995           }
14996         printf ("\"\n");
14997         return p;
14998       }
14999     }
15000
15001   return display_tag_value (tag, p, end);
15002 }
15003
15004 static void
15005 display_raw_attribute (unsigned char * p, unsigned char const * const end)
15006 {
15007   unsigned long addr = 0;
15008   size_t bytes = end - p;
15009
15010   assert (end > p);
15011   while (bytes)
15012     {
15013       int j;
15014       int k;
15015       int lbytes = (bytes > 16 ? 16 : bytes);
15016
15017       printf ("  0x%8.8lx ", addr);
15018
15019       for (j = 0; j < 16; j++)
15020         {
15021           if (j < lbytes)
15022             printf ("%2.2x", p[j]);
15023           else
15024             printf ("  ");
15025
15026           if ((j & 3) == 3)
15027             printf (" ");
15028         }
15029
15030       for (j = 0; j < lbytes; j++)
15031         {
15032           k = p[j];
15033           if (k >= ' ' && k < 0x7f)
15034             printf ("%c", k);
15035           else
15036             printf (".");
15037         }
15038
15039       putchar ('\n');
15040
15041       p  += lbytes;
15042       bytes -= lbytes;
15043       addr += lbytes;
15044     }
15045
15046   putchar ('\n');
15047 }
15048
15049 static unsigned char *
15050 display_msp430x_attribute (unsigned char * p,
15051                            const unsigned char * const end)
15052 {
15053   unsigned int len;
15054   unsigned int val;
15055   unsigned int tag;
15056
15057   tag = read_uleb128 (p, & len, end);
15058   p += len;
15059
15060   switch (tag)
15061     {
15062     case OFBA_MSPABI_Tag_ISA:
15063       val = read_uleb128 (p, &len, end);
15064       p += len;
15065       printf ("  Tag_ISA: ");
15066       switch (val)
15067         {
15068         case 0: printf (_("None\n")); break;
15069         case 1: printf (_("MSP430\n")); break;
15070         case 2: printf (_("MSP430X\n")); break;
15071         default: printf ("??? (%d)\n", val); break;
15072         }
15073       break;
15074
15075     case OFBA_MSPABI_Tag_Code_Model:
15076       val = read_uleb128 (p, &len, end);
15077       p += len;
15078       printf ("  Tag_Code_Model: ");
15079       switch (val)
15080         {
15081         case 0: printf (_("None\n")); break;
15082         case 1: printf (_("Small\n")); break;
15083         case 2: printf (_("Large\n")); break;
15084         default: printf ("??? (%d)\n", val); break;
15085         }
15086       break;
15087
15088     case OFBA_MSPABI_Tag_Data_Model:
15089       val = read_uleb128 (p, &len, end);
15090       p += len;
15091       printf ("  Tag_Data_Model: ");
15092       switch (val)
15093         {
15094         case 0: printf (_("None\n")); break;
15095         case 1: printf (_("Small\n")); break;
15096         case 2: printf (_("Large\n")); break;
15097         case 3: printf (_("Restricted Large\n")); break;
15098         default: printf ("??? (%d)\n", val); break;
15099         }
15100       break;
15101
15102     default:
15103       printf (_("  <unknown tag %d>: "), tag);
15104
15105       if (tag & 1)
15106         {
15107           putchar ('"');
15108           if (p < end - 1)
15109             {
15110               size_t maxlen = (end - p) - 1;
15111
15112               print_symbol ((int) maxlen, (const char *) p);
15113               p += strnlen ((char *) p, maxlen) + 1;
15114             }
15115           else
15116             {
15117               printf (_("<corrupt>"));
15118               p = (unsigned char *) end;
15119             }
15120           printf ("\"\n");
15121         }
15122       else
15123         {
15124           val = read_uleb128 (p, &len, end);
15125           p += len;
15126           printf ("%d (0x%x)\n", val, val);
15127         }
15128       break;
15129    }
15130
15131   assert (p <= end);
15132   return p;
15133 }
15134
15135 static bfd_boolean
15136 process_attributes (Filedata * filedata,
15137                     const char * public_name,
15138                     unsigned int proc_type,
15139                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15140                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15141 {
15142   Elf_Internal_Shdr * sect;
15143   unsigned i;
15144   bfd_boolean res = TRUE;
15145
15146   /* Find the section header so that we get the size.  */
15147   for (i = 0, sect = filedata->section_headers;
15148        i < filedata->file_header.e_shnum;
15149        i++, sect++)
15150     {
15151       unsigned char * contents;
15152       unsigned char * p;
15153
15154       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15155         continue;
15156
15157       contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15158                                              sect->sh_size, _("attributes"));
15159       if (contents == NULL)
15160         {
15161           res = FALSE;
15162           continue;
15163         }
15164
15165       p = contents;
15166       /* The first character is the version of the attributes.
15167          Currently only version 1, (aka 'A') is recognised here.  */
15168       if (*p != 'A')
15169         {
15170           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15171           res = FALSE;
15172         }
15173       else
15174         {
15175           bfd_vma section_len;
15176
15177           section_len = sect->sh_size - 1;
15178           p++;
15179
15180           while (section_len > 0)
15181             {
15182               bfd_vma attr_len;
15183               unsigned int namelen;
15184               bfd_boolean public_section;
15185               bfd_boolean gnu_section;
15186
15187               if (section_len <= 4)
15188                 {
15189                   error (_("Tag section ends prematurely\n"));
15190                   res = FALSE;
15191                   break;
15192                 }
15193               attr_len = byte_get (p, 4);
15194               p += 4;
15195
15196               if (attr_len > section_len)
15197                 {
15198                   error (_("Bad attribute length (%u > %u)\n"),
15199                           (unsigned) attr_len, (unsigned) section_len);
15200                   attr_len = section_len;
15201                   res = FALSE;
15202                 }
15203               /* PR 17531: file: 001-101425-0.004  */
15204               else if (attr_len < 5)
15205                 {
15206                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
15207                   res = FALSE;
15208                   break;
15209                 }
15210
15211               section_len -= attr_len;
15212               attr_len -= 4;
15213
15214               namelen = strnlen ((char *) p, attr_len) + 1;
15215               if (namelen == 0 || namelen >= attr_len)
15216                 {
15217                   error (_("Corrupt attribute section name\n"));
15218                   res = FALSE;
15219                   break;
15220                 }
15221
15222               printf (_("Attribute Section: "));
15223               print_symbol (INT_MAX, (const char *) p);
15224               putchar ('\n');
15225
15226               if (public_name && streq ((char *) p, public_name))
15227                 public_section = TRUE;
15228               else
15229                 public_section = FALSE;
15230
15231               if (streq ((char *) p, "gnu"))
15232                 gnu_section = TRUE;
15233               else
15234                 gnu_section = FALSE;
15235
15236               p += namelen;
15237               attr_len -= namelen;
15238
15239               while (attr_len > 0 && p < contents + sect->sh_size)
15240                 {
15241                   int tag;
15242                   int val;
15243                   bfd_vma size;
15244                   unsigned char * end;
15245
15246                   /* PR binutils/17531: Safe handling of corrupt files.  */
15247                   if (attr_len < 6)
15248                     {
15249                       error (_("Unused bytes at end of section\n"));
15250                       res = FALSE;
15251                       section_len = 0;
15252                       break;
15253                     }
15254
15255                   tag = *(p++);
15256                   size = byte_get (p, 4);
15257                   if (size > attr_len)
15258                     {
15259                       error (_("Bad subsection length (%u > %u)\n"),
15260                               (unsigned) size, (unsigned) attr_len);
15261                       res = FALSE;
15262                       size = attr_len;
15263                     }
15264                   /* PR binutils/17531: Safe handling of corrupt files.  */
15265                   if (size < 6)
15266                     {
15267                       error (_("Bad subsection length (%u < 6)\n"),
15268                               (unsigned) size);
15269                       res = FALSE;
15270                       section_len = 0;
15271                       break;
15272                     }
15273
15274                   attr_len -= size;
15275                   end = p + size - 1;
15276                   assert (end <= contents + sect->sh_size);
15277                   p += 4;
15278
15279                   switch (tag)
15280                     {
15281                     case 1:
15282                       printf (_("File Attributes\n"));
15283                       break;
15284                     case 2:
15285                       printf (_("Section Attributes:"));
15286                       goto do_numlist;
15287                     case 3:
15288                       printf (_("Symbol Attributes:"));
15289                       /* Fall through.  */
15290                     do_numlist:
15291                       for (;;)
15292                         {
15293                           unsigned int j;
15294
15295                           val = read_uleb128 (p, &j, end);
15296                           p += j;
15297                           if (val == 0)
15298                             break;
15299                           printf (" %d", val);
15300                         }
15301                       printf ("\n");
15302                       break;
15303                     default:
15304                       printf (_("Unknown tag: %d\n"), tag);
15305                       public_section = FALSE;
15306                       break;
15307                     }
15308
15309                   if (public_section && display_pub_attribute != NULL)
15310                     {
15311                       while (p < end)
15312                         p = display_pub_attribute (p, end);
15313                       assert (p == end);
15314                     }
15315                   else if (gnu_section && display_proc_gnu_attribute != NULL)
15316                     {
15317                       while (p < end)
15318                         p = display_gnu_attribute (p,
15319                                                    display_proc_gnu_attribute,
15320                                                    end);
15321                       assert (p == end);
15322                     }
15323                   else if (p < end)
15324                     {
15325                       printf (_("  Unknown attribute:\n"));
15326                       display_raw_attribute (p, end);
15327                       p = end;
15328                     }
15329                   else
15330                     attr_len = 0;
15331                 }
15332             }
15333         }
15334
15335       free (contents);
15336     }
15337
15338   return res;
15339 }
15340
15341 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15342    Print the Address, Access and Initial fields of an entry at VMA ADDR
15343    and return the VMA of the next entry, or -1 if there was a problem.
15344    Does not read from DATA_END or beyond.  */
15345
15346 static bfd_vma
15347 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15348                       unsigned char * data_end)
15349 {
15350   printf ("  ");
15351   print_vma (addr, LONG_HEX);
15352   printf (" ");
15353   if (addr < pltgot + 0xfff0)
15354     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15355   else
15356     printf ("%10s", "");
15357   printf (" ");
15358   if (data == NULL)
15359     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15360   else
15361     {
15362       bfd_vma entry;
15363       unsigned char * from = data + addr - pltgot;
15364
15365       if (from + (is_32bit_elf ? 4 : 8) > data_end)
15366         {
15367           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15368           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15369           return (bfd_vma) -1;
15370         }
15371       else
15372         {
15373           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15374           print_vma (entry, LONG_HEX);
15375         }
15376     }
15377   return addr + (is_32bit_elf ? 4 : 8);
15378 }
15379
15380 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15381    PLTGOT.  Print the Address and Initial fields of an entry at VMA
15382    ADDR and return the VMA of the next entry.  */
15383
15384 static bfd_vma
15385 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15386 {
15387   printf ("  ");
15388   print_vma (addr, LONG_HEX);
15389   printf (" ");
15390   if (data == NULL)
15391     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15392   else
15393     {
15394       bfd_vma entry;
15395
15396       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15397       print_vma (entry, LONG_HEX);
15398     }
15399   return addr + (is_32bit_elf ? 4 : 8);
15400 }
15401
15402 static void
15403 print_mips_ases (unsigned int mask)
15404 {
15405   if (mask & AFL_ASE_DSP)
15406     fputs ("\n\tDSP ASE", stdout);
15407   if (mask & AFL_ASE_DSPR2)
15408     fputs ("\n\tDSP R2 ASE", stdout);
15409   if (mask & AFL_ASE_DSPR3)
15410     fputs ("\n\tDSP R3 ASE", stdout);
15411   if (mask & AFL_ASE_EVA)
15412     fputs ("\n\tEnhanced VA Scheme", stdout);
15413   if (mask & AFL_ASE_MCU)
15414     fputs ("\n\tMCU (MicroController) ASE", stdout);
15415   if (mask & AFL_ASE_MDMX)
15416     fputs ("\n\tMDMX ASE", stdout);
15417   if (mask & AFL_ASE_MIPS3D)
15418     fputs ("\n\tMIPS-3D ASE", stdout);
15419   if (mask & AFL_ASE_MT)
15420     fputs ("\n\tMT ASE", stdout);
15421   if (mask & AFL_ASE_SMARTMIPS)
15422     fputs ("\n\tSmartMIPS ASE", stdout);
15423   if (mask & AFL_ASE_VIRT)
15424     fputs ("\n\tVZ ASE", stdout);
15425   if (mask & AFL_ASE_MSA)
15426     fputs ("\n\tMSA ASE", stdout);
15427   if (mask & AFL_ASE_MIPS16)
15428     fputs ("\n\tMIPS16 ASE", stdout);
15429   if (mask & AFL_ASE_MICROMIPS)
15430     fputs ("\n\tMICROMIPS ASE", stdout);
15431   if (mask & AFL_ASE_XPA)
15432     fputs ("\n\tXPA ASE", stdout);
15433   if (mask & AFL_ASE_MIPS16E2)
15434     fputs ("\n\tMIPS16e2 ASE", stdout);
15435   if (mask == 0)
15436     fprintf (stdout, "\n\t%s", _("None"));
15437   else if ((mask & ~AFL_ASE_MASK) != 0)
15438     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15439 }
15440
15441 static void
15442 print_mips_isa_ext (unsigned int isa_ext)
15443 {
15444   switch (isa_ext)
15445     {
15446     case 0:
15447       fputs (_("None"), stdout);
15448       break;
15449     case AFL_EXT_XLR:
15450       fputs ("RMI XLR", stdout);
15451       break;
15452     case AFL_EXT_OCTEON3:
15453       fputs ("Cavium Networks Octeon3", stdout);
15454       break;
15455     case AFL_EXT_OCTEON2:
15456       fputs ("Cavium Networks Octeon2", stdout);
15457       break;
15458     case AFL_EXT_OCTEONP:
15459       fputs ("Cavium Networks OcteonP", stdout);
15460       break;
15461     case AFL_EXT_LOONGSON_3A:
15462       fputs ("Loongson 3A", stdout);
15463       break;
15464     case AFL_EXT_OCTEON:
15465       fputs ("Cavium Networks Octeon", stdout);
15466       break;
15467     case AFL_EXT_5900:
15468       fputs ("Toshiba R5900", stdout);
15469       break;
15470     case AFL_EXT_4650:
15471       fputs ("MIPS R4650", stdout);
15472       break;
15473     case AFL_EXT_4010:
15474       fputs ("LSI R4010", stdout);
15475       break;
15476     case AFL_EXT_4100:
15477       fputs ("NEC VR4100", stdout);
15478       break;
15479     case AFL_EXT_3900:
15480       fputs ("Toshiba R3900", stdout);
15481       break;
15482     case AFL_EXT_10000:
15483       fputs ("MIPS R10000", stdout);
15484       break;
15485     case AFL_EXT_SB1:
15486       fputs ("Broadcom SB-1", stdout);
15487       break;
15488     case AFL_EXT_4111:
15489       fputs ("NEC VR4111/VR4181", stdout);
15490       break;
15491     case AFL_EXT_4120:
15492       fputs ("NEC VR4120", stdout);
15493       break;
15494     case AFL_EXT_5400:
15495       fputs ("NEC VR5400", stdout);
15496       break;
15497     case AFL_EXT_5500:
15498       fputs ("NEC VR5500", stdout);
15499       break;
15500     case AFL_EXT_LOONGSON_2E:
15501       fputs ("ST Microelectronics Loongson 2E", stdout);
15502       break;
15503     case AFL_EXT_LOONGSON_2F:
15504       fputs ("ST Microelectronics Loongson 2F", stdout);
15505       break;
15506     case AFL_EXT_INTERAPTIV_MR2:
15507       fputs ("Imagination interAptiv MR2", stdout);
15508       break;
15509     default:
15510       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15511     }
15512 }
15513
15514 static signed int
15515 get_mips_reg_size (int reg_size)
15516 {
15517   return (reg_size == AFL_REG_NONE) ? 0
15518          : (reg_size == AFL_REG_32) ? 32
15519          : (reg_size == AFL_REG_64) ? 64
15520          : (reg_size == AFL_REG_128) ? 128
15521          : -1;
15522 }
15523
15524 static bfd_boolean
15525 process_mips_specific (Filedata * filedata)
15526 {
15527   Elf_Internal_Dyn * entry;
15528   Elf_Internal_Shdr *sect = NULL;
15529   size_t liblist_offset = 0;
15530   size_t liblistno = 0;
15531   size_t conflictsno = 0;
15532   size_t options_offset = 0;
15533   size_t conflicts_offset = 0;
15534   size_t pltrelsz = 0;
15535   size_t pltrel = 0;
15536   bfd_vma pltgot = 0;
15537   bfd_vma mips_pltgot = 0;
15538   bfd_vma jmprel = 0;
15539   bfd_vma local_gotno = 0;
15540   bfd_vma gotsym = 0;
15541   bfd_vma symtabno = 0;
15542   bfd_boolean res = TRUE;
15543
15544   if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
15545                             display_mips_gnu_attribute))
15546     res = FALSE;
15547
15548   sect = find_section (filedata, ".MIPS.abiflags");
15549
15550   if (sect != NULL)
15551     {
15552       Elf_External_ABIFlags_v0 *abiflags_ext;
15553       Elf_Internal_ABIFlags_v0 abiflags_in;
15554
15555       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15556         {
15557           error (_("Corrupt MIPS ABI Flags section.\n"));
15558           res = FALSE;
15559         }
15560       else
15561         {
15562           abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
15563                                    sect->sh_size, _("MIPS ABI Flags section"));
15564           if (abiflags_ext)
15565             {
15566               abiflags_in.version = BYTE_GET (abiflags_ext->version);
15567               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15568               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15569               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15570               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15571               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15572               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15573               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15574               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15575               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15576               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15577
15578               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15579               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15580               if (abiflags_in.isa_rev > 1)
15581                 printf ("r%d", abiflags_in.isa_rev);
15582               printf ("\nGPR size: %d",
15583                       get_mips_reg_size (abiflags_in.gpr_size));
15584               printf ("\nCPR1 size: %d",
15585                       get_mips_reg_size (abiflags_in.cpr1_size));
15586               printf ("\nCPR2 size: %d",
15587                       get_mips_reg_size (abiflags_in.cpr2_size));
15588               fputs ("\nFP ABI: ", stdout);
15589               print_mips_fp_abi_value (abiflags_in.fp_abi);
15590               fputs ("ISA Extension: ", stdout);
15591               print_mips_isa_ext (abiflags_in.isa_ext);
15592               fputs ("\nASEs:", stdout);
15593               print_mips_ases (abiflags_in.ases);
15594               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15595               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15596               fputc ('\n', stdout);
15597               free (abiflags_ext);
15598             }
15599         }
15600     }
15601
15602   /* We have a lot of special sections.  Thanks SGI!  */
15603   if (dynamic_section == NULL)
15604     {
15605       /* No dynamic information available.  See if there is static GOT.  */
15606       sect = find_section (filedata, ".got");
15607       if (sect != NULL)
15608         {
15609           unsigned char *data_end;
15610           unsigned char *data;
15611           bfd_vma ent, end;
15612           int addr_size;
15613
15614           pltgot = sect->sh_addr;
15615
15616           ent = pltgot;
15617           addr_size = (is_32bit_elf ? 4 : 8);
15618           end = pltgot + sect->sh_size;
15619
15620           data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
15621                                              end - pltgot, 1,
15622                                              _("Global Offset Table data"));
15623           /* PR 12855: Null data is handled gracefully throughout.  */
15624           data_end = data + (end - pltgot);
15625
15626           printf (_("\nStatic GOT:\n"));
15627           printf (_(" Canonical gp value: "));
15628           print_vma (ent + 0x7ff0, LONG_HEX);
15629           printf ("\n\n");
15630
15631           /* In a dynamic binary GOT[0] is reserved for the dynamic
15632              loader to store the lazy resolver pointer, however in
15633              a static binary it may well have been omitted and GOT
15634              reduced to a table of addresses.
15635              PR 21344: Check for the entry being fully available
15636              before fetching it.  */
15637           if (data
15638               && data + ent - pltgot + addr_size <= data_end
15639               && byte_get (data + ent - pltgot, addr_size) == 0)
15640             {
15641               printf (_(" Reserved entries:\n"));
15642               printf (_("  %*s %10s %*s\n"),
15643                       addr_size * 2, _("Address"), _("Access"),
15644                       addr_size * 2, _("Value"));
15645               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15646               printf ("\n");
15647               if (ent == (bfd_vma) -1)
15648                 goto sgot_print_fail;
15649
15650               /* Check for the MSB of GOT[1] being set, identifying a
15651                  GNU object.  This entry will be used by some runtime
15652                  loaders, to store the module pointer.  Otherwise this
15653                  is an ordinary local entry.
15654                  PR 21344: Check for the entry being fully available
15655                  before fetching it.  */
15656               if (data
15657                   && data + ent - pltgot + addr_size <= data_end
15658                   && (byte_get (data + ent - pltgot, addr_size)
15659                       >> (addr_size * 8 - 1)) != 0)
15660                 {
15661                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15662                   printf ("\n");
15663                   if (ent == (bfd_vma) -1)
15664                     goto sgot_print_fail;
15665                 }
15666               printf ("\n");
15667             }
15668
15669           if (data != NULL && ent < end)
15670             {
15671               printf (_(" Local entries:\n"));
15672               printf ("  %*s %10s %*s\n",
15673                       addr_size * 2, _("Address"), _("Access"),
15674                       addr_size * 2, _("Value"));
15675               while (ent < end)
15676                 {
15677                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15678                   printf ("\n");
15679                   if (ent == (bfd_vma) -1)
15680                     goto sgot_print_fail;
15681                 }
15682               printf ("\n");
15683             }
15684
15685         sgot_print_fail:
15686           if (data)
15687             free (data);
15688         }
15689       return res;
15690     }
15691
15692   for (entry = dynamic_section;
15693        /* PR 17531 file: 012-50589-0.004.  */
15694        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15695        ++entry)
15696     switch (entry->d_tag)
15697       {
15698       case DT_MIPS_LIBLIST:
15699         liblist_offset
15700           = offset_from_vma (filedata, entry->d_un.d_val,
15701                              liblistno * sizeof (Elf32_External_Lib));
15702         break;
15703       case DT_MIPS_LIBLISTNO:
15704         liblistno = entry->d_un.d_val;
15705         break;
15706       case DT_MIPS_OPTIONS:
15707         options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
15708         break;
15709       case DT_MIPS_CONFLICT:
15710         conflicts_offset
15711           = offset_from_vma (filedata, entry->d_un.d_val,
15712                              conflictsno * sizeof (Elf32_External_Conflict));
15713         break;
15714       case DT_MIPS_CONFLICTNO:
15715         conflictsno = entry->d_un.d_val;
15716         break;
15717       case DT_PLTGOT:
15718         pltgot = entry->d_un.d_ptr;
15719         break;
15720       case DT_MIPS_LOCAL_GOTNO:
15721         local_gotno = entry->d_un.d_val;
15722         break;
15723       case DT_MIPS_GOTSYM:
15724         gotsym = entry->d_un.d_val;
15725         break;
15726       case DT_MIPS_SYMTABNO:
15727         symtabno = entry->d_un.d_val;
15728         break;
15729       case DT_MIPS_PLTGOT:
15730         mips_pltgot = entry->d_un.d_ptr;
15731         break;
15732       case DT_PLTREL:
15733         pltrel = entry->d_un.d_val;
15734         break;
15735       case DT_PLTRELSZ:
15736         pltrelsz = entry->d_un.d_val;
15737         break;
15738       case DT_JMPREL:
15739         jmprel = entry->d_un.d_ptr;
15740         break;
15741       default:
15742         break;
15743       }
15744
15745   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15746     {
15747       Elf32_External_Lib * elib;
15748       size_t cnt;
15749
15750       elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
15751                                               liblistno,
15752                                               sizeof (Elf32_External_Lib),
15753                                               _("liblist section data"));
15754       if (elib)
15755         {
15756           printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15757                             "\nSection '.liblist' contains %lu entries:\n",
15758                             (unsigned long) liblistno),
15759                   (unsigned long) liblistno);
15760           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
15761                  stdout);
15762
15763           for (cnt = 0; cnt < liblistno; ++cnt)
15764             {
15765               Elf32_Lib liblist;
15766               time_t atime;
15767               char timebuf[128];
15768               struct tm * tmp;
15769
15770               liblist.l_name = BYTE_GET (elib[cnt].l_name);
15771               atime = BYTE_GET (elib[cnt].l_time_stamp);
15772               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15773               liblist.l_version = BYTE_GET (elib[cnt].l_version);
15774               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15775
15776               tmp = gmtime (&atime);
15777               snprintf (timebuf, sizeof (timebuf),
15778                         "%04u-%02u-%02uT%02u:%02u:%02u",
15779                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15780                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15781
15782               printf ("%3lu: ", (unsigned long) cnt);
15783               if (VALID_DYNAMIC_NAME (liblist.l_name))
15784                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
15785               else
15786                 printf (_("<corrupt: %9ld>"), liblist.l_name);
15787               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
15788                       liblist.l_version);
15789
15790               if (liblist.l_flags == 0)
15791                 puts (_(" NONE"));
15792               else
15793                 {
15794                   static const struct
15795                   {
15796                     const char * name;
15797                     int bit;
15798                   }
15799                   l_flags_vals[] =
15800                   {
15801                     { " EXACT_MATCH", LL_EXACT_MATCH },
15802                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
15803                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
15804                     { " EXPORTS", LL_EXPORTS },
15805                     { " DELAY_LOAD", LL_DELAY_LOAD },
15806                     { " DELTA", LL_DELTA }
15807                   };
15808                   int flags = liblist.l_flags;
15809                   size_t fcnt;
15810
15811                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
15812                     if ((flags & l_flags_vals[fcnt].bit) != 0)
15813                       {
15814                         fputs (l_flags_vals[fcnt].name, stdout);
15815                         flags ^= l_flags_vals[fcnt].bit;
15816                       }
15817                   if (flags != 0)
15818                     printf (" %#x", (unsigned int) flags);
15819
15820                   puts ("");
15821                 }
15822             }
15823
15824           free (elib);
15825         }
15826       else
15827         res = FALSE;
15828     }
15829
15830   if (options_offset != 0)
15831     {
15832       Elf_External_Options * eopt;
15833       Elf_Internal_Options * iopt;
15834       Elf_Internal_Options * option;
15835       size_t offset;
15836       int cnt;
15837       sect = filedata->section_headers;
15838
15839       /* Find the section header so that we get the size.  */
15840       sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
15841       /* PR 17533 file: 012-277276-0.004.  */
15842       if (sect == NULL)
15843         {
15844           error (_("No MIPS_OPTIONS header found\n"));
15845           return FALSE;
15846         }
15847
15848       eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
15849                                                 sect->sh_size, _("options"));
15850       if (eopt)
15851         {
15852           iopt = (Elf_Internal_Options *)
15853               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
15854           if (iopt == NULL)
15855             {
15856               error (_("Out of memory allocating space for MIPS options\n"));
15857               return FALSE;
15858             }
15859
15860           offset = cnt = 0;
15861           option = iopt;
15862
15863           while (offset <= sect->sh_size - sizeof (* eopt))
15864             {
15865               Elf_External_Options * eoption;
15866
15867               eoption = (Elf_External_Options *) ((char *) eopt + offset);
15868
15869               option->kind = BYTE_GET (eoption->kind);
15870               option->size = BYTE_GET (eoption->size);
15871               option->section = BYTE_GET (eoption->section);
15872               option->info = BYTE_GET (eoption->info);
15873
15874               /* PR 17531: file: ffa0fa3b.  */
15875               if (option->size < sizeof (* eopt)
15876                   || offset + option->size > sect->sh_size)
15877                 {
15878                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
15879                   return FALSE;
15880                 }
15881               offset += option->size;
15882
15883               ++option;
15884               ++cnt;
15885             }
15886
15887           printf (ngettext ("\nSection '%s' contains %d entry:\n",
15888                             "\nSection '%s' contains %d entries:\n",
15889                             cnt),
15890                   printable_section_name (filedata, sect), cnt);
15891
15892           option = iopt;
15893           offset = 0;
15894
15895           while (cnt-- > 0)
15896             {
15897               size_t len;
15898
15899               switch (option->kind)
15900                 {
15901                 case ODK_NULL:
15902                   /* This shouldn't happen.  */
15903                   printf (" NULL       %d %lx", option->section, option->info);
15904                   break;
15905                 case ODK_REGINFO:
15906                   printf (" REGINFO    ");
15907                   if (filedata->file_header.e_machine == EM_MIPS)
15908                     {
15909                       /* 32bit form.  */
15910                       Elf32_External_RegInfo * ereg;
15911                       Elf32_RegInfo reginfo;
15912
15913                       ereg = (Elf32_External_RegInfo *) (option + 1);
15914                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15915                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15916                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15917                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15918                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15919                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
15920
15921                       printf ("GPR %08lx  GP 0x%lx\n",
15922                               reginfo.ri_gprmask,
15923                               (unsigned long) reginfo.ri_gp_value);
15924                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15925                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15926                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15927                     }
15928                   else
15929                     {
15930                       /* 64 bit form.  */
15931                       Elf64_External_RegInfo * ereg;
15932                       Elf64_Internal_RegInfo reginfo;
15933
15934                       ereg = (Elf64_External_RegInfo *) (option + 1);
15935                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
15936                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15937                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15938                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15939                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15940                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
15941
15942                       printf ("GPR %08lx  GP 0x",
15943                               reginfo.ri_gprmask);
15944                       printf_vma (reginfo.ri_gp_value);
15945                       printf ("\n");
15946
15947                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15948                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15949                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15950                     }
15951                   ++option;
15952                   continue;
15953                 case ODK_EXCEPTIONS:
15954                   fputs (" EXCEPTIONS fpe_min(", stdout);
15955                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
15956                   fputs (") fpe_max(", stdout);
15957                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
15958                   fputs (")", stdout);
15959
15960                   if (option->info & OEX_PAGE0)
15961                     fputs (" PAGE0", stdout);
15962                   if (option->info & OEX_SMM)
15963                     fputs (" SMM", stdout);
15964                   if (option->info & OEX_FPDBUG)
15965                     fputs (" FPDBUG", stdout);
15966                   if (option->info & OEX_DISMISS)
15967                     fputs (" DISMISS", stdout);
15968                   break;
15969                 case ODK_PAD:
15970                   fputs (" PAD       ", stdout);
15971                   if (option->info & OPAD_PREFIX)
15972                     fputs (" PREFIX", stdout);
15973                   if (option->info & OPAD_POSTFIX)
15974                     fputs (" POSTFIX", stdout);
15975                   if (option->info & OPAD_SYMBOL)
15976                     fputs (" SYMBOL", stdout);
15977                   break;
15978                 case ODK_HWPATCH:
15979                   fputs (" HWPATCH   ", stdout);
15980                   if (option->info & OHW_R4KEOP)
15981                     fputs (" R4KEOP", stdout);
15982                   if (option->info & OHW_R8KPFETCH)
15983                     fputs (" R8KPFETCH", stdout);
15984                   if (option->info & OHW_R5KEOP)
15985                     fputs (" R5KEOP", stdout);
15986                   if (option->info & OHW_R5KCVTL)
15987                     fputs (" R5KCVTL", stdout);
15988                   break;
15989                 case ODK_FILL:
15990                   fputs (" FILL       ", stdout);
15991                   /* XXX Print content of info word?  */
15992                   break;
15993                 case ODK_TAGS:
15994                   fputs (" TAGS       ", stdout);
15995                   /* XXX Print content of info word?  */
15996                   break;
15997                 case ODK_HWAND:
15998                   fputs (" HWAND     ", stdout);
15999                   if (option->info & OHWA0_R4KEOP_CHECKED)
16000                     fputs (" R4KEOP_CHECKED", stdout);
16001                   if (option->info & OHWA0_R4KEOP_CLEAN)
16002                     fputs (" R4KEOP_CLEAN", stdout);
16003                   break;
16004                 case ODK_HWOR:
16005                   fputs (" HWOR      ", stdout);
16006                   if (option->info & OHWA0_R4KEOP_CHECKED)
16007                     fputs (" R4KEOP_CHECKED", stdout);
16008                   if (option->info & OHWA0_R4KEOP_CLEAN)
16009                     fputs (" R4KEOP_CLEAN", stdout);
16010                   break;
16011                 case ODK_GP_GROUP:
16012                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
16013                           option->info & OGP_GROUP,
16014                           (option->info & OGP_SELF) >> 16);
16015                   break;
16016                 case ODK_IDENT:
16017                   printf (" IDENT     %#06lx  self-contained %#06lx",
16018                           option->info & OGP_GROUP,
16019                           (option->info & OGP_SELF) >> 16);
16020                   break;
16021                 default:
16022                   /* This shouldn't happen.  */
16023                   printf (" %3d ???     %d %lx",
16024                           option->kind, option->section, option->info);
16025                   break;
16026                 }
16027
16028               len = sizeof (* eopt);
16029               while (len < option->size)
16030                 {
16031                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
16032
16033                   if (ISPRINT (datum))
16034                     printf ("%c", datum);
16035                   else
16036                     printf ("\\%03o", datum);
16037                   len ++;
16038                 }
16039               fputs ("\n", stdout);
16040
16041               offset += option->size;
16042               ++option;
16043             }
16044
16045           free (eopt);
16046         }
16047       else
16048         res = FALSE;
16049     }
16050
16051   if (conflicts_offset != 0 && conflictsno != 0)
16052     {
16053       Elf32_Conflict * iconf;
16054       size_t cnt;
16055
16056       if (dynamic_symbols == NULL)
16057         {
16058           error (_("conflict list found without a dynamic symbol table\n"));
16059           return FALSE;
16060         }
16061
16062       /* PR 21345 - print a slightly more helpful error message
16063          if we are sure that the cmalloc will fail.  */
16064       if (conflictsno * sizeof (* iconf) > filedata->file_size)
16065         {
16066           error (_("Overlarge number of conflicts detected: %lx\n"),
16067                  (long) conflictsno);
16068           return FALSE;
16069         }
16070
16071       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16072       if (iconf == NULL)
16073         {
16074           error (_("Out of memory allocating space for dynamic conflicts\n"));
16075           return FALSE;
16076         }
16077
16078       if (is_32bit_elf)
16079         {
16080           Elf32_External_Conflict * econf32;
16081
16082           econf32 = (Elf32_External_Conflict *)
16083               get_data (NULL, filedata, conflicts_offset, conflictsno,
16084                         sizeof (* econf32), _("conflict"));
16085           if (!econf32)
16086             return FALSE;
16087
16088           for (cnt = 0; cnt < conflictsno; ++cnt)
16089             iconf[cnt] = BYTE_GET (econf32[cnt]);
16090
16091           free (econf32);
16092         }
16093       else
16094         {
16095           Elf64_External_Conflict * econf64;
16096
16097           econf64 = (Elf64_External_Conflict *)
16098               get_data (NULL, filedata, conflicts_offset, conflictsno,
16099                         sizeof (* econf64), _("conflict"));
16100           if (!econf64)
16101             return FALSE;
16102
16103           for (cnt = 0; cnt < conflictsno; ++cnt)
16104             iconf[cnt] = BYTE_GET (econf64[cnt]);
16105
16106           free (econf64);
16107         }
16108
16109       printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16110                         "\nSection '.conflict' contains %lu entries:\n",
16111                         (unsigned long) conflictsno),
16112               (unsigned long) conflictsno);
16113       puts (_("  Num:    Index       Value  Name"));
16114
16115       for (cnt = 0; cnt < conflictsno; ++cnt)
16116         {
16117           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
16118
16119           if (iconf[cnt] >= num_dynamic_syms)
16120             printf (_("<corrupt symbol index>"));
16121           else
16122             {
16123               Elf_Internal_Sym * psym;
16124
16125               psym = & dynamic_symbols[iconf[cnt]];
16126               print_vma (psym->st_value, FULL_HEX);
16127               putchar (' ');
16128               if (VALID_DYNAMIC_NAME (psym->st_name))
16129                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16130               else
16131                 printf (_("<corrupt: %14ld>"), psym->st_name);
16132             }
16133           putchar ('\n');
16134         }
16135
16136       free (iconf);
16137     }
16138
16139   if (pltgot != 0 && local_gotno != 0)
16140     {
16141       bfd_vma ent, local_end, global_end;
16142       size_t i, offset;
16143       unsigned char * data;
16144       unsigned char * data_end;
16145       int addr_size;
16146
16147       ent = pltgot;
16148       addr_size = (is_32bit_elf ? 4 : 8);
16149       local_end = pltgot + local_gotno * addr_size;
16150
16151       /* PR binutils/17533 file: 012-111227-0.004  */
16152       if (symtabno < gotsym)
16153         {
16154           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16155                  (unsigned long) gotsym, (unsigned long) symtabno);
16156           return FALSE;
16157         }
16158
16159       global_end = local_end + (symtabno - gotsym) * addr_size;
16160       /* PR 17531: file: 54c91a34.  */
16161       if (global_end < local_end)
16162         {
16163           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
16164           return FALSE;
16165         }
16166
16167       offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
16168       data = (unsigned char *) get_data (NULL, filedata, offset,
16169                                          global_end - pltgot, 1,
16170                                          _("Global Offset Table data"));
16171       /* PR 12855: Null data is handled gracefully throughout.  */
16172       data_end = data + (global_end - pltgot);
16173
16174       printf (_("\nPrimary GOT:\n"));
16175       printf (_(" Canonical gp value: "));
16176       print_vma (pltgot + 0x7ff0, LONG_HEX);
16177       printf ("\n\n");
16178
16179       printf (_(" Reserved entries:\n"));
16180       printf (_("  %*s %10s %*s Purpose\n"),
16181               addr_size * 2, _("Address"), _("Access"),
16182               addr_size * 2, _("Initial"));
16183       ent = print_mips_got_entry (data, pltgot, ent, data_end);
16184       printf (_(" Lazy resolver\n"));
16185       if (ent == (bfd_vma) -1)
16186         goto got_print_fail;
16187
16188       /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16189          This entry will be used by some runtime loaders, to store the
16190          module pointer.  Otherwise this is an ordinary local entry.
16191          PR 21344: Check for the entry being fully available before
16192          fetching it.  */
16193       if (data
16194           && data + ent - pltgot + addr_size <= data_end
16195           && (byte_get (data + ent - pltgot, addr_size)
16196               >> (addr_size * 8 - 1)) != 0)
16197         {
16198           ent = print_mips_got_entry (data, pltgot, ent, data_end);
16199           printf (_(" Module pointer (GNU extension)\n"));
16200           if (ent == (bfd_vma) -1)
16201             goto got_print_fail;
16202         }
16203       printf ("\n");
16204
16205       if (data != NULL && ent < local_end)
16206         {
16207           printf (_(" Local entries:\n"));
16208           printf ("  %*s %10s %*s\n",
16209                   addr_size * 2, _("Address"), _("Access"),
16210                   addr_size * 2, _("Initial"));
16211           while (ent < local_end)
16212             {
16213               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16214               printf ("\n");
16215               if (ent == (bfd_vma) -1)
16216                 goto got_print_fail;
16217             }
16218           printf ("\n");
16219         }
16220
16221       if (data != NULL && gotsym < symtabno)
16222         {
16223           int sym_width;
16224
16225           printf (_(" Global entries:\n"));
16226           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
16227                   addr_size * 2, _("Address"),
16228                   _("Access"),
16229                   addr_size * 2, _("Initial"),
16230                   addr_size * 2, _("Sym.Val."),
16231                   _("Type"),
16232                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
16233                   _("Ndx"), _("Name"));
16234
16235           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
16236
16237           for (i = gotsym; i < symtabno; i++)
16238             {
16239               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16240               printf (" ");
16241
16242               if (dynamic_symbols == NULL)
16243                 printf (_("<no dynamic symbols>"));
16244               else if (i < num_dynamic_syms)
16245                 {
16246                   Elf_Internal_Sym * psym = dynamic_symbols + i;
16247
16248                   print_vma (psym->st_value, LONG_HEX);
16249                   printf (" %-7s %3s ",
16250                           get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16251                           get_symbol_index_type (filedata, psym->st_shndx));
16252
16253                   if (VALID_DYNAMIC_NAME (psym->st_name))
16254                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16255                   else
16256                     printf (_("<corrupt: %14ld>"), psym->st_name);
16257                 }
16258               else
16259                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16260                         (unsigned long) i);
16261
16262               printf ("\n");
16263               if (ent == (bfd_vma) -1)
16264                 break;
16265             }
16266           printf ("\n");
16267         }
16268
16269     got_print_fail:
16270       if (data)
16271         free (data);
16272     }
16273
16274   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
16275     {
16276       bfd_vma ent, end;
16277       size_t offset, rel_offset;
16278       unsigned long count, i;
16279       unsigned char * data;
16280       int addr_size, sym_width;
16281       Elf_Internal_Rela * rels;
16282
16283       rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
16284       if (pltrel == DT_RELA)
16285         {
16286           if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16287             return FALSE;
16288         }
16289       else
16290         {
16291           if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16292             return FALSE;
16293         }
16294
16295       ent = mips_pltgot;
16296       addr_size = (is_32bit_elf ? 4 : 8);
16297       end = mips_pltgot + (2 + count) * addr_size;
16298
16299       offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
16300       data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
16301                                          1, _("Procedure Linkage Table data"));
16302       if (data == NULL)
16303         return FALSE;
16304
16305       printf ("\nPLT GOT:\n\n");
16306       printf (_(" Reserved entries:\n"));
16307       printf (_("  %*s %*s Purpose\n"),
16308               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
16309       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16310       printf (_(" PLT lazy resolver\n"));
16311       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16312       printf (_(" Module pointer\n"));
16313       printf ("\n");
16314
16315       printf (_(" Entries:\n"));
16316       printf ("  %*s %*s %*s %-7s %3s %s\n",
16317               addr_size * 2, _("Address"),
16318               addr_size * 2, _("Initial"),
16319               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16320       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
16321       for (i = 0; i < count; i++)
16322         {
16323           unsigned long idx = get_reloc_symindex (rels[i].r_info);
16324
16325           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16326           printf (" ");
16327
16328           if (idx >= num_dynamic_syms)
16329             printf (_("<corrupt symbol index: %lu>"), idx);
16330           else
16331             {
16332               Elf_Internal_Sym * psym = dynamic_symbols + idx;
16333
16334               print_vma (psym->st_value, LONG_HEX);
16335               printf (" %-7s %3s ",
16336                       get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16337                       get_symbol_index_type (filedata, psym->st_shndx));
16338               if (VALID_DYNAMIC_NAME (psym->st_name))
16339                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16340               else
16341                 printf (_("<corrupt: %14ld>"), psym->st_name);
16342             }
16343           printf ("\n");
16344         }
16345       printf ("\n");
16346
16347       if (data)
16348         free (data);
16349       free (rels);
16350     }
16351
16352   return res;
16353 }
16354
16355 static bfd_boolean
16356 process_nds32_specific (Filedata * filedata)
16357 {
16358   Elf_Internal_Shdr *sect = NULL;
16359
16360   sect = find_section (filedata, ".nds32_e_flags");
16361   if (sect != NULL)
16362     {
16363       unsigned int *flag;
16364
16365       printf ("\nNDS32 elf flags section:\n");
16366       flag = get_data (NULL, filedata, sect->sh_offset, 1,
16367                        sect->sh_size, _("NDS32 elf flags section"));
16368
16369       if (! flag)
16370         return FALSE;
16371
16372       switch ((*flag) & 0x3)
16373         {
16374         case 0:
16375           printf ("(VEC_SIZE):\tNo entry.\n");
16376           break;
16377         case 1:
16378           printf ("(VEC_SIZE):\t4 bytes\n");
16379           break;
16380         case 2:
16381           printf ("(VEC_SIZE):\t16 bytes\n");
16382           break;
16383         case 3:
16384           printf ("(VEC_SIZE):\treserved\n");
16385           break;
16386         }
16387     }
16388
16389   return TRUE;
16390 }
16391
16392 static bfd_boolean
16393 process_gnu_liblist (Filedata * filedata)
16394 {
16395   Elf_Internal_Shdr * section;
16396   Elf_Internal_Shdr * string_sec;
16397   Elf32_External_Lib * elib;
16398   char * strtab;
16399   size_t strtab_size;
16400   size_t cnt;
16401   unsigned long num_liblist;
16402   unsigned i;
16403   bfd_boolean res = TRUE;
16404
16405   if (! do_arch)
16406     return TRUE;
16407
16408   for (i = 0, section = filedata->section_headers;
16409        i < filedata->file_header.e_shnum;
16410        i++, section++)
16411     {
16412       switch (section->sh_type)
16413         {
16414         case SHT_GNU_LIBLIST:
16415           if (section->sh_link >= filedata->file_header.e_shnum)
16416             break;
16417
16418           elib = (Elf32_External_Lib *)
16419               get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
16420                         _("liblist section data"));
16421
16422           if (elib == NULL)
16423             {
16424               res = FALSE;
16425               break;
16426             }
16427
16428           string_sec = filedata->section_headers + section->sh_link;
16429           strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
16430                                       string_sec->sh_size,
16431                                       _("liblist string table"));
16432           if (strtab == NULL
16433               || section->sh_entsize != sizeof (Elf32_External_Lib))
16434             {
16435               free (elib);
16436               free (strtab);
16437               res = FALSE;
16438               break;
16439             }
16440           strtab_size = string_sec->sh_size;
16441
16442           num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
16443           printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16444                             "\nLibrary list section '%s' contains %lu entries:\n",
16445                             num_liblist),
16446                   printable_section_name (filedata, section),
16447                   num_liblist);
16448
16449           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
16450
16451           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16452                ++cnt)
16453             {
16454               Elf32_Lib liblist;
16455               time_t atime;
16456               char timebuf[128];
16457               struct tm * tmp;
16458
16459               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16460               atime = BYTE_GET (elib[cnt].l_time_stamp);
16461               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16462               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16463               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16464
16465               tmp = gmtime (&atime);
16466               snprintf (timebuf, sizeof (timebuf),
16467                         "%04u-%02u-%02uT%02u:%02u:%02u",
16468                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16469                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16470
16471               printf ("%3lu: ", (unsigned long) cnt);
16472               if (do_wide)
16473                 printf ("%-20s", liblist.l_name < strtab_size
16474                         ? strtab + liblist.l_name : _("<corrupt>"));
16475               else
16476                 printf ("%-20.20s", liblist.l_name < strtab_size
16477                         ? strtab + liblist.l_name : _("<corrupt>"));
16478               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16479                       liblist.l_version, liblist.l_flags);
16480             }
16481
16482           free (elib);
16483           free (strtab);
16484         }
16485     }
16486
16487   return res;
16488 }
16489
16490 static const char *
16491 get_note_type (Filedata * filedata, unsigned e_type)
16492 {
16493   static char buff[64];
16494
16495   if (filedata->file_header.e_type == ET_CORE)
16496     switch (e_type)
16497       {
16498       case NT_AUXV:
16499         return _("NT_AUXV (auxiliary vector)");
16500       case NT_PRSTATUS:
16501         return _("NT_PRSTATUS (prstatus structure)");
16502       case NT_FPREGSET:
16503         return _("NT_FPREGSET (floating point registers)");
16504       case NT_PRPSINFO:
16505         return _("NT_PRPSINFO (prpsinfo structure)");
16506       case NT_TASKSTRUCT:
16507         return _("NT_TASKSTRUCT (task structure)");
16508       case NT_PRXFPREG:
16509         return _("NT_PRXFPREG (user_xfpregs structure)");
16510       case NT_PPC_VMX:
16511         return _("NT_PPC_VMX (ppc Altivec registers)");
16512       case NT_PPC_VSX:
16513         return _("NT_PPC_VSX (ppc VSX registers)");
16514       case NT_PPC_TAR:
16515         return _("NT_PPC_TAR (ppc TAR register)");
16516       case NT_PPC_PPR:
16517         return _("NT_PPC_PPR (ppc PPR register)");
16518       case NT_PPC_DSCR:
16519         return _("NT_PPC_DSCR (ppc DSCR register)");
16520       case NT_PPC_EBB:
16521         return _("NT_PPC_EBB (ppc EBB registers)");
16522       case NT_PPC_PMU:
16523         return _("NT_PPC_PMU (ppc PMU registers)");
16524       case NT_PPC_TM_CGPR:
16525         return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16526       case NT_PPC_TM_CFPR:
16527         return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16528       case NT_PPC_TM_CVMX:
16529         return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16530       case NT_PPC_TM_CVSX:
16531         return _("NT_PPC_TM_VSX (ppc checkpointed VSX registers)");
16532       case NT_PPC_TM_SPR:
16533         return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16534       case NT_PPC_TM_CTAR:
16535         return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16536       case NT_PPC_TM_CPPR:
16537         return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16538       case NT_PPC_TM_CDSCR:
16539         return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16540       case NT_386_TLS:
16541         return _("NT_386_TLS (x86 TLS information)");
16542       case NT_386_IOPERM:
16543         return _("NT_386_IOPERM (x86 I/O permissions)");
16544       case NT_X86_XSTATE:
16545         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16546       case NT_S390_HIGH_GPRS:
16547         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16548       case NT_S390_TIMER:
16549         return _("NT_S390_TIMER (s390 timer register)");
16550       case NT_S390_TODCMP:
16551         return _("NT_S390_TODCMP (s390 TOD comparator register)");
16552       case NT_S390_TODPREG:
16553         return _("NT_S390_TODPREG (s390 TOD programmable register)");
16554       case NT_S390_CTRS:
16555         return _("NT_S390_CTRS (s390 control registers)");
16556       case NT_S390_PREFIX:
16557         return _("NT_S390_PREFIX (s390 prefix register)");
16558       case NT_S390_LAST_BREAK:
16559         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16560       case NT_S390_SYSTEM_CALL:
16561         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16562       case NT_S390_TDB:
16563         return _("NT_S390_TDB (s390 transaction diagnostic block)");
16564       case NT_S390_VXRS_LOW:
16565         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16566       case NT_S390_VXRS_HIGH:
16567         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16568       case NT_S390_GS_CB:
16569         return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16570       case NT_S390_GS_BC:
16571         return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16572       case NT_ARM_VFP:
16573         return _("NT_ARM_VFP (arm VFP registers)");
16574       case NT_ARM_TLS:
16575         return _("NT_ARM_TLS (AArch TLS registers)");
16576       case NT_ARM_HW_BREAK:
16577         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16578       case NT_ARM_HW_WATCH:
16579         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16580       case NT_PSTATUS:
16581         return _("NT_PSTATUS (pstatus structure)");
16582       case NT_FPREGS:
16583         return _("NT_FPREGS (floating point registers)");
16584       case NT_PSINFO:
16585         return _("NT_PSINFO (psinfo structure)");
16586       case NT_LWPSTATUS:
16587         return _("NT_LWPSTATUS (lwpstatus_t structure)");
16588       case NT_LWPSINFO:
16589         return _("NT_LWPSINFO (lwpsinfo_t structure)");
16590       case NT_WIN32PSTATUS:
16591         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16592       case NT_SIGINFO:
16593         return _("NT_SIGINFO (siginfo_t data)");
16594       case NT_FILE:
16595         return _("NT_FILE (mapped files)");
16596       default:
16597         break;
16598       }
16599   else
16600     switch (e_type)
16601       {
16602       case NT_VERSION:
16603         return _("NT_VERSION (version)");
16604       case NT_ARCH:
16605         return _("NT_ARCH (architecture)");
16606       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16607         return _("OPEN");
16608       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16609         return _("func");
16610       default:
16611         break;
16612       }
16613
16614   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16615   return buff;
16616 }
16617
16618 static bfd_boolean
16619 print_core_note (Elf_Internal_Note *pnote)
16620 {
16621   unsigned int addr_size = is_32bit_elf ? 4 : 8;
16622   bfd_vma count, page_size;
16623   unsigned char *descdata, *filenames, *descend;
16624
16625   if (pnote->type != NT_FILE)
16626     {
16627       if (do_wide)
16628         printf ("\n");
16629       return TRUE;
16630     }
16631
16632 #ifndef BFD64
16633   if (!is_32bit_elf)
16634     {
16635       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
16636       /* Still "successful".  */
16637       return TRUE;
16638     }
16639 #endif
16640
16641   if (pnote->descsz < 2 * addr_size)
16642     {
16643       error (_("    Malformed note - too short for header\n"));
16644       return FALSE;
16645     }
16646
16647   descdata = (unsigned char *) pnote->descdata;
16648   descend = descdata + pnote->descsz;
16649
16650   if (descdata[pnote->descsz - 1] != '\0')
16651     {
16652       error (_("    Malformed note - does not end with \\0\n"));
16653       return FALSE;
16654     }
16655
16656   count = byte_get (descdata, addr_size);
16657   descdata += addr_size;
16658
16659   page_size = byte_get (descdata, addr_size);
16660   descdata += addr_size;
16661
16662   if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
16663       || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16664     {
16665       error (_("    Malformed note - too short for supplied file count\n"));
16666       return FALSE;
16667     }
16668
16669   printf (_("    Page size: "));
16670   print_vma (page_size, DEC);
16671   printf ("\n");
16672
16673   printf (_("    %*s%*s%*s\n"),
16674           (int) (2 + 2 * addr_size), _("Start"),
16675           (int) (4 + 2 * addr_size), _("End"),
16676           (int) (4 + 2 * addr_size), _("Page Offset"));
16677   filenames = descdata + count * 3 * addr_size;
16678   while (count-- > 0)
16679     {
16680       bfd_vma start, end, file_ofs;
16681
16682       if (filenames == descend)
16683         {
16684           error (_("    Malformed note - filenames end too early\n"));
16685           return FALSE;
16686         }
16687
16688       start = byte_get (descdata, addr_size);
16689       descdata += addr_size;
16690       end = byte_get (descdata, addr_size);
16691       descdata += addr_size;
16692       file_ofs = byte_get (descdata, addr_size);
16693       descdata += addr_size;
16694
16695       printf ("    ");
16696       print_vma (start, FULL_HEX);
16697       printf ("  ");
16698       print_vma (end, FULL_HEX);
16699       printf ("  ");
16700       print_vma (file_ofs, FULL_HEX);
16701       printf ("\n        %s\n", filenames);
16702
16703       filenames += 1 + strlen ((char *) filenames);
16704     }
16705
16706   return TRUE;
16707 }
16708
16709 static const char *
16710 get_gnu_elf_note_type (unsigned e_type)
16711 {
16712   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
16713   switch (e_type)
16714     {
16715     case NT_GNU_ABI_TAG:
16716       return _("NT_GNU_ABI_TAG (ABI version tag)");
16717     case NT_GNU_HWCAP:
16718       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16719     case NT_GNU_BUILD_ID:
16720       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16721     case NT_GNU_GOLD_VERSION:
16722       return _("NT_GNU_GOLD_VERSION (gold version)");
16723     case NT_GNU_PROPERTY_TYPE_0:
16724       return _("NT_GNU_PROPERTY_TYPE_0");
16725     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16726       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16727     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16728       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16729     default:
16730       {
16731         static char buff[64];
16732
16733         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16734         return buff;
16735       }
16736     }
16737 }
16738
16739 static void
16740 decode_x86_isa (unsigned int bitmask)
16741 {
16742   while (bitmask)
16743     {
16744       unsigned int bit = bitmask & (- bitmask);
16745
16746       bitmask &= ~ bit;
16747       switch (bit)
16748         {
16749         case GNU_PROPERTY_X86_ISA_1_486: printf ("i486"); break;
16750         case GNU_PROPERTY_X86_ISA_1_586: printf ("586"); break;
16751         case GNU_PROPERTY_X86_ISA_1_686: printf ("686"); break;
16752         case GNU_PROPERTY_X86_ISA_1_SSE: printf ("SSE"); break;
16753         case GNU_PROPERTY_X86_ISA_1_SSE2: printf ("SSE2"); break;
16754         case GNU_PROPERTY_X86_ISA_1_SSE3: printf ("SSE3"); break;
16755         case GNU_PROPERTY_X86_ISA_1_SSSE3: printf ("SSSE3"); break;
16756         case GNU_PROPERTY_X86_ISA_1_SSE4_1: printf ("SSE4_1"); break;
16757         case GNU_PROPERTY_X86_ISA_1_SSE4_2: printf ("SSE4_2"); break;
16758         case GNU_PROPERTY_X86_ISA_1_AVX: printf ("AVX"); break;
16759         case GNU_PROPERTY_X86_ISA_1_AVX2: printf ("AVX2"); break;
16760         case GNU_PROPERTY_X86_ISA_1_AVX512F: printf ("AVX512F"); break;
16761         case GNU_PROPERTY_X86_ISA_1_AVX512CD: printf ("AVX512CD"); break;
16762         case GNU_PROPERTY_X86_ISA_1_AVX512ER: printf ("AVX512ER"); break;
16763         case GNU_PROPERTY_X86_ISA_1_AVX512PF: printf ("AVX512PF"); break;
16764         case GNU_PROPERTY_X86_ISA_1_AVX512VL: printf ("AVX512VL"); break;
16765         case GNU_PROPERTY_X86_ISA_1_AVX512DQ: printf ("AVX512DQ"); break;
16766         case GNU_PROPERTY_X86_ISA_1_AVX512BW: printf ("AVX512BW"); break;
16767         default: printf (_("<unknown: %x>"), bit); break;
16768         }
16769       if (bitmask)
16770         printf (", ");
16771     }
16772 }
16773
16774 static void
16775 decode_x86_feature (unsigned int type, unsigned int bitmask)
16776 {
16777   while (bitmask)
16778     {
16779       unsigned int bit = bitmask & (- bitmask);
16780
16781       bitmask &= ~ bit;
16782       switch (bit)
16783         {
16784         case GNU_PROPERTY_X86_FEATURE_1_IBT:
16785           switch (type)
16786             {
16787             case GNU_PROPERTY_X86_FEATURE_1_AND:
16788               printf ("IBT");
16789               break;
16790             default:
16791               /* This should never happen.  */
16792               abort ();
16793             }
16794           break;
16795         case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
16796           switch (type)
16797             {
16798             case GNU_PROPERTY_X86_FEATURE_1_AND:
16799               printf ("SHSTK");
16800               break;
16801             default:
16802               /* This should never happen.  */
16803               abort ();
16804             }
16805           break;
16806         default:
16807           printf (_("<unknown: %x>"), bit);
16808           break;
16809         }
16810       if (bitmask)
16811         printf (", ");
16812     }
16813 }
16814
16815 static void
16816 print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
16817 {
16818   unsigned char * ptr = (unsigned char *) pnote->descdata;
16819   unsigned char * ptr_end = ptr + pnote->descsz;
16820   unsigned int    size = is_32bit_elf ? 4 : 8;
16821
16822   printf (_("      Properties: "));
16823
16824   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
16825     {
16826       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
16827       return;
16828     }
16829
16830   while (ptr < ptr_end)
16831     {
16832       unsigned int j;
16833       unsigned int type;
16834       unsigned int datasz;
16835
16836       if ((size_t) (ptr_end - ptr) < 8)
16837         {
16838           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
16839           break;
16840         }
16841
16842       type = byte_get (ptr, 4);
16843       datasz = byte_get (ptr + 4, 4);
16844
16845       ptr += 8;
16846
16847       if (datasz > (size_t) (ptr_end - ptr))
16848         {
16849           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16850                   type, datasz);
16851           break;
16852         }
16853
16854       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
16855         {
16856           if (filedata->file_header.e_machine == EM_X86_64
16857               || filedata->file_header.e_machine == EM_IAMCU
16858               || filedata->file_header.e_machine == EM_386)
16859             {
16860               switch (type)
16861                 {
16862                 case GNU_PROPERTY_X86_ISA_1_USED:
16863                   printf ("x86 ISA used: ");
16864                   if (datasz != 4)
16865                     printf (_("<corrupt length: %#x> "), datasz);
16866                   else
16867                     decode_x86_isa (byte_get (ptr, 4));
16868                   goto next;
16869
16870                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
16871                   printf ("x86 ISA needed: ");
16872                   if (datasz != 4)
16873                     printf (_("<corrupt length: %#x> "), datasz);
16874                   else
16875                     decode_x86_isa (byte_get (ptr, 4));
16876                   goto next;
16877
16878                 case GNU_PROPERTY_X86_FEATURE_1_AND:
16879                   printf ("x86 feature: ");
16880                   if (datasz != 4)
16881                     printf (_("<corrupt length: %#x> "), datasz);
16882                   else
16883                     decode_x86_feature (type, byte_get (ptr, 4));
16884                   goto next;
16885
16886                 default:
16887                   break;
16888                 }
16889             }
16890         }
16891       else
16892         {
16893           switch (type)
16894             {
16895             case GNU_PROPERTY_STACK_SIZE:
16896               printf (_("stack size: "));
16897               if (datasz != size)
16898                 printf (_("<corrupt length: %#x> "), datasz);
16899               else
16900                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
16901               goto next;
16902
16903             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
16904               printf ("no copy on protected ");
16905               if (datasz)
16906                 printf (_("<corrupt length: %#x> "), datasz);
16907               goto next;
16908
16909             default:
16910               break;
16911             }
16912         }
16913
16914       if (type < GNU_PROPERTY_LOPROC)
16915         printf (_("<unknown type %#x data: "), type);
16916       else if (type < GNU_PROPERTY_LOUSER)
16917         printf (_("<procesor-specific type %#x data: "), type);
16918       else
16919         printf (_("<application-specific type %#x data: "), type);
16920       for (j = 0; j < datasz; ++j)
16921         printf ("%02x ", ptr[j] & 0xff);
16922       printf (">");
16923
16924 next:
16925       ptr += ((datasz + (size - 1)) & ~ (size - 1));
16926       if (ptr == ptr_end)
16927         break;
16928
16929       if (do_wide)
16930         printf (", ");
16931       else
16932         printf ("\n\t");
16933     }
16934
16935   printf ("\n");
16936 }
16937
16938 static bfd_boolean
16939 print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
16940 {
16941   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
16942   switch (pnote->type)
16943     {
16944     case NT_GNU_BUILD_ID:
16945       {
16946         unsigned long i;
16947
16948         printf (_("    Build ID: "));
16949         for (i = 0; i < pnote->descsz; ++i)
16950           printf ("%02x", pnote->descdata[i] & 0xff);
16951         printf ("\n");
16952       }
16953       break;
16954
16955     case NT_GNU_ABI_TAG:
16956       {
16957         unsigned long os, major, minor, subminor;
16958         const char *osname;
16959
16960         /* PR 17531: file: 030-599401-0.004.  */
16961         if (pnote->descsz < 16)
16962           {
16963             printf (_("    <corrupt GNU_ABI_TAG>\n"));
16964             break;
16965           }
16966
16967         os = byte_get ((unsigned char *) pnote->descdata, 4);
16968         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16969         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
16970         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
16971
16972         switch (os)
16973           {
16974           case GNU_ABI_TAG_LINUX:
16975             osname = "Linux";
16976             break;
16977           case GNU_ABI_TAG_HURD:
16978             osname = "Hurd";
16979             break;
16980           case GNU_ABI_TAG_SOLARIS:
16981             osname = "Solaris";
16982             break;
16983           case GNU_ABI_TAG_FREEBSD:
16984             osname = "FreeBSD";
16985             break;
16986           case GNU_ABI_TAG_NETBSD:
16987             osname = "NetBSD";
16988             break;
16989           case GNU_ABI_TAG_SYLLABLE:
16990             osname = "Syllable";
16991             break;
16992           case GNU_ABI_TAG_NACL:
16993             osname = "NaCl";
16994             break;
16995           default:
16996             osname = "Unknown";
16997             break;
16998           }
16999
17000         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
17001                 major, minor, subminor);
17002       }
17003       break;
17004
17005     case NT_GNU_GOLD_VERSION:
17006       {
17007         unsigned long i;
17008
17009         printf (_("    Version: "));
17010         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
17011           printf ("%c", pnote->descdata[i]);
17012         printf ("\n");
17013       }
17014       break;
17015
17016     case NT_GNU_HWCAP:
17017       {
17018         unsigned long num_entries, mask;
17019
17020         /* Hardware capabilities information.  Word 0 is the number of entries.
17021            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
17022            is a series of entries, where each entry is a single byte followed
17023            by a nul terminated string.  The byte gives the bit number to test
17024            if enabled in the bitmask.  */
17025         printf (_("      Hardware Capabilities: "));
17026         if (pnote->descsz < 8)
17027           {
17028             error (_("<corrupt GNU_HWCAP>\n"));
17029             return FALSE;
17030           }
17031         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
17032         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17033         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
17034         /* FIXME: Add code to display the entries... */
17035       }
17036       break;
17037
17038     case NT_GNU_PROPERTY_TYPE_0:
17039       print_gnu_property_note (filedata, pnote);
17040       break;
17041
17042     default:
17043       /* Handle unrecognised types.  An error message should have already been
17044          created by get_gnu_elf_note_type(), so all that we need to do is to
17045          display the data.  */
17046       {
17047         unsigned long i;
17048
17049         printf (_("    Description data: "));
17050         for (i = 0; i < pnote->descsz; ++i)
17051           printf ("%02x ", pnote->descdata[i] & 0xff);
17052         printf ("\n");
17053       }
17054       break;
17055     }
17056
17057   return TRUE;
17058 }
17059
17060 static const char *
17061 get_v850_elf_note_type (enum v850_notes n_type)
17062 {
17063   static char buff[64];
17064
17065   switch (n_type)
17066     {
17067     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
17068     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
17069     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
17070     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
17071     case V850_NOTE_CACHE_INFO: return _("Use of cache");
17072     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
17073     default:
17074       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
17075       return buff;
17076     }
17077 }
17078
17079 static bfd_boolean
17080 print_v850_note (Elf_Internal_Note * pnote)
17081 {
17082   unsigned int val;
17083
17084   if (pnote->descsz != 4)
17085     return FALSE;
17086
17087   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
17088
17089   if (val == 0)
17090     {
17091       printf (_("not set\n"));
17092       return TRUE;
17093     }
17094
17095   switch (pnote->type)
17096     {
17097     case V850_NOTE_ALIGNMENT:
17098       switch (val)
17099         {
17100         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
17101         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
17102         }
17103       break;
17104
17105     case V850_NOTE_DATA_SIZE:
17106       switch (val)
17107         {
17108         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
17109         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
17110         }
17111       break;
17112
17113     case V850_NOTE_FPU_INFO:
17114       switch (val)
17115         {
17116         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
17117         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
17118         }
17119       break;
17120
17121     case V850_NOTE_MMU_INFO:
17122     case V850_NOTE_CACHE_INFO:
17123     case V850_NOTE_SIMD_INFO:
17124       if (val == EF_RH850_SIMD)
17125         {
17126           printf (_("yes\n"));
17127           return TRUE;
17128         }
17129       break;
17130
17131     default:
17132       /* An 'unknown note type' message will already have been displayed.  */
17133       break;
17134     }
17135
17136   printf (_("unknown value: %x\n"), val);
17137   return FALSE;
17138 }
17139
17140 static bfd_boolean
17141 process_netbsd_elf_note (Elf_Internal_Note * pnote)
17142 {
17143   unsigned int version;
17144
17145   switch (pnote->type)
17146     {
17147     case NT_NETBSD_IDENT:
17148       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
17149       if ((version / 10000) % 100)
17150         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
17151                 version, version / 100000000, (version / 1000000) % 100,
17152                 (version / 10000) % 100 > 26 ? "Z" : "",
17153                 'A' + (version / 10000) % 26);
17154       else
17155         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
17156                 version, version / 100000000, (version / 1000000) % 100,
17157                 (version / 100) % 100);
17158       return TRUE;
17159
17160     case NT_NETBSD_MARCH:
17161       printf ("  NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
17162               pnote->descdata);
17163       return TRUE;
17164
17165     default:
17166       printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
17167               pnote->type);
17168       return FALSE;
17169     }
17170 }
17171
17172 static const char *
17173 get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17174 {
17175   switch (e_type)
17176     {
17177     case NT_FREEBSD_THRMISC:
17178       return _("NT_THRMISC (thrmisc structure)");
17179     case NT_FREEBSD_PROCSTAT_PROC:
17180       return _("NT_PROCSTAT_PROC (proc data)");
17181     case NT_FREEBSD_PROCSTAT_FILES:
17182       return _("NT_PROCSTAT_FILES (files data)");
17183     case NT_FREEBSD_PROCSTAT_VMMAP:
17184       return _("NT_PROCSTAT_VMMAP (vmmap data)");
17185     case NT_FREEBSD_PROCSTAT_GROUPS:
17186       return _("NT_PROCSTAT_GROUPS (groups data)");
17187     case NT_FREEBSD_PROCSTAT_UMASK:
17188       return _("NT_PROCSTAT_UMASK (umask data)");
17189     case NT_FREEBSD_PROCSTAT_RLIMIT:
17190       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17191     case NT_FREEBSD_PROCSTAT_OSREL:
17192       return _("NT_PROCSTAT_OSREL (osreldate data)");
17193     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
17194       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17195     case NT_FREEBSD_PROCSTAT_AUXV:
17196       return _("NT_PROCSTAT_AUXV (auxv data)");
17197     case NT_FREEBSD_PTLWPINFO:
17198       return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17199     }
17200   return get_note_type (filedata, e_type);
17201 }
17202
17203 static const char *
17204 get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17205 {
17206   static char buff[64];
17207
17208   if (e_type == NT_NETBSDCORE_PROCINFO)
17209     return _("NetBSD procinfo structure");
17210
17211   /* As of Jan 2002 there are no other machine-independent notes
17212      defined for NetBSD core files.  If the note type is less
17213      than the start of the machine-dependent note types, we don't
17214      understand it.  */
17215
17216   if (e_type < NT_NETBSDCORE_FIRSTMACH)
17217     {
17218       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17219       return buff;
17220     }
17221
17222   switch (filedata->file_header.e_machine)
17223     {
17224     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17225        and PT_GETFPREGS == mach+2.  */
17226
17227     case EM_OLD_ALPHA:
17228     case EM_ALPHA:
17229     case EM_SPARC:
17230     case EM_SPARC32PLUS:
17231     case EM_SPARCV9:
17232       switch (e_type)
17233         {
17234         case NT_NETBSDCORE_FIRSTMACH + 0:
17235           return _("PT_GETREGS (reg structure)");
17236         case NT_NETBSDCORE_FIRSTMACH + 2:
17237           return _("PT_GETFPREGS (fpreg structure)");
17238         default:
17239           break;
17240         }
17241       break;
17242
17243     /* On all other arch's, PT_GETREGS == mach+1 and
17244        PT_GETFPREGS == mach+3.  */
17245     default:
17246       switch (e_type)
17247         {
17248         case NT_NETBSDCORE_FIRSTMACH + 1:
17249           return _("PT_GETREGS (reg structure)");
17250         case NT_NETBSDCORE_FIRSTMACH + 3:
17251           return _("PT_GETFPREGS (fpreg structure)");
17252         default:
17253           break;
17254         }
17255     }
17256
17257   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
17258             e_type - NT_NETBSDCORE_FIRSTMACH);
17259   return buff;
17260 }
17261
17262 static const char *
17263 get_stapsdt_note_type (unsigned e_type)
17264 {
17265   static char buff[64];
17266
17267   switch (e_type)
17268     {
17269     case NT_STAPSDT:
17270       return _("NT_STAPSDT (SystemTap probe descriptors)");
17271
17272     default:
17273       break;
17274     }
17275
17276   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17277   return buff;
17278 }
17279
17280 static bfd_boolean
17281 print_stapsdt_note (Elf_Internal_Note *pnote)
17282 {
17283   int addr_size = is_32bit_elf ? 4 : 8;
17284   char *data = pnote->descdata;
17285   char *data_end = pnote->descdata + pnote->descsz;
17286   bfd_vma pc, base_addr, semaphore;
17287   char *provider, *probe, *arg_fmt;
17288
17289   pc = byte_get ((unsigned char *) data, addr_size);
17290   data += addr_size;
17291   base_addr = byte_get ((unsigned char *) data, addr_size);
17292   data += addr_size;
17293   semaphore = byte_get ((unsigned char *) data, addr_size);
17294   data += addr_size;
17295
17296   provider = data;
17297   data += strlen (data) + 1;
17298   probe = data;
17299   data += strlen (data) + 1;
17300   arg_fmt = data;
17301   data += strlen (data) + 1;
17302
17303   printf (_("    Provider: %s\n"), provider);
17304   printf (_("    Name: %s\n"), probe);
17305   printf (_("    Location: "));
17306   print_vma (pc, FULL_HEX);
17307   printf (_(", Base: "));
17308   print_vma (base_addr, FULL_HEX);
17309   printf (_(", Semaphore: "));
17310   print_vma (semaphore, FULL_HEX);
17311   printf ("\n");
17312   printf (_("    Arguments: %s\n"), arg_fmt);
17313
17314   return data == data_end;
17315 }
17316
17317 static const char *
17318 get_ia64_vms_note_type (unsigned e_type)
17319 {
17320   static char buff[64];
17321
17322   switch (e_type)
17323     {
17324     case NT_VMS_MHD:
17325       return _("NT_VMS_MHD (module header)");
17326     case NT_VMS_LNM:
17327       return _("NT_VMS_LNM (language name)");
17328     case NT_VMS_SRC:
17329       return _("NT_VMS_SRC (source files)");
17330     case NT_VMS_TITLE:
17331       return "NT_VMS_TITLE";
17332     case NT_VMS_EIDC:
17333       return _("NT_VMS_EIDC (consistency check)");
17334     case NT_VMS_FPMODE:
17335       return _("NT_VMS_FPMODE (FP mode)");
17336     case NT_VMS_LINKTIME:
17337       return "NT_VMS_LINKTIME";
17338     case NT_VMS_IMGNAM:
17339       return _("NT_VMS_IMGNAM (image name)");
17340     case NT_VMS_IMGID:
17341       return _("NT_VMS_IMGID (image id)");
17342     case NT_VMS_LINKID:
17343       return _("NT_VMS_LINKID (link id)");
17344     case NT_VMS_IMGBID:
17345       return _("NT_VMS_IMGBID (build id)");
17346     case NT_VMS_GSTNAM:
17347       return _("NT_VMS_GSTNAM (sym table name)");
17348     case NT_VMS_ORIG_DYN:
17349       return "NT_VMS_ORIG_DYN";
17350     case NT_VMS_PATCHTIME:
17351       return "NT_VMS_PATCHTIME";
17352     default:
17353       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17354       return buff;
17355     }
17356 }
17357
17358 static bfd_boolean
17359 print_ia64_vms_note (Elf_Internal_Note * pnote)
17360 {
17361   switch (pnote->type)
17362     {
17363     case NT_VMS_MHD:
17364       if (pnote->descsz > 36)
17365         {
17366           size_t l = strlen (pnote->descdata + 34);
17367           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
17368           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
17369           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
17370           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
17371         }
17372       else
17373         printf (_("    Invalid size\n"));
17374       break;
17375     case NT_VMS_LNM:
17376       printf (_("   Language: %s\n"), pnote->descdata);
17377       break;
17378 #ifdef BFD64
17379     case NT_VMS_FPMODE:
17380       printf (_("   Floating Point mode: "));
17381       printf ("0x%016" BFD_VMA_FMT "x\n",
17382               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
17383       break;
17384     case NT_VMS_LINKTIME:
17385       printf (_("   Link time: "));
17386       print_vms_time
17387         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17388       printf ("\n");
17389       break;
17390     case NT_VMS_PATCHTIME:
17391       printf (_("   Patch time: "));
17392       print_vms_time
17393         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17394       printf ("\n");
17395       break;
17396     case NT_VMS_ORIG_DYN:
17397       printf (_("   Major id: %u,  minor id: %u\n"),
17398               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
17399               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
17400       printf (_("   Last modified  : "));
17401       print_vms_time
17402         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
17403       printf (_("\n   Link flags  : "));
17404       printf ("0x%016" BFD_VMA_FMT "x\n",
17405               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
17406       printf (_("   Header flags: 0x%08x\n"),
17407               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
17408       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
17409       break;
17410 #endif
17411     case NT_VMS_IMGNAM:
17412       printf (_("    Image name: %s\n"), pnote->descdata);
17413       break;
17414     case NT_VMS_GSTNAM:
17415       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
17416       break;
17417     case NT_VMS_IMGID:
17418       printf (_("    Image id: %s\n"), pnote->descdata);
17419       break;
17420     case NT_VMS_LINKID:
17421       printf (_("    Linker id: %s\n"), pnote->descdata);
17422       break;
17423     default:
17424       return FALSE;
17425     }
17426   return TRUE;
17427 }
17428
17429 /* Find the symbol associated with a build attribute that is attached
17430    to address OFFSET.  If PNAME is non-NULL then store the name of
17431    the symbol (if found) in the provided pointer,  Returns NULL if a
17432    symbol could not be found.  */
17433
17434 static Elf_Internal_Sym *
17435 get_symbol_for_build_attribute (Filedata *       filedata,
17436                                 unsigned long    offset,
17437                                 bfd_boolean      is_open_attr,
17438                                 const char **    pname)
17439 {
17440   static Filedata *         saved_filedata = NULL;
17441   static char *             strtab;
17442   static unsigned long      strtablen;
17443   static Elf_Internal_Sym * symtab;
17444   static unsigned long      nsyms;
17445   Elf_Internal_Sym *        saved_sym = NULL;
17446   Elf_Internal_Sym *        sym;
17447
17448   if (filedata->section_headers != NULL
17449       && (saved_filedata == NULL || filedata != saved_filedata))
17450     {
17451       Elf_Internal_Shdr * symsec;
17452
17453       /* Load the symbol and string sections.  */
17454       for (symsec = filedata->section_headers;
17455            symsec < filedata->section_headers + filedata->file_header.e_shnum;
17456            symsec ++)
17457         {
17458           if (symsec->sh_type == SHT_SYMTAB)
17459             {
17460               symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
17461
17462               if (symsec->sh_link < filedata->file_header.e_shnum)
17463                 {
17464                   Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
17465
17466                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
17467                                               1, strtab_sec->sh_size,
17468                                               _("string table"));
17469                   strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
17470                 }
17471             }
17472         }
17473       saved_filedata = filedata;
17474     }
17475
17476   if (symtab == NULL || strtab == NULL)
17477     return NULL;
17478
17479   /* Find a symbol whose value matches offset.  */
17480   for (sym = symtab; sym < symtab + nsyms; sym ++)
17481     if (sym->st_value == offset)
17482       {
17483         if (sym->st_name >= strtablen)
17484           /* Huh ?  This should not happen.  */
17485           continue;
17486
17487         if (strtab[sym->st_name] == 0)
17488           continue;
17489
17490         if (is_open_attr)
17491           {
17492             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17493                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
17494                FUNC symbols entirely.  */
17495             switch (ELF_ST_TYPE (sym->st_info))
17496               {
17497               case STT_OBJECT:
17498               case STT_FILE:
17499                 saved_sym = sym;
17500                 if (sym->st_size)
17501                   {
17502                     /* If the symbol has a size associated
17503                        with it then we can stop searching.  */
17504                     sym = symtab + nsyms;
17505                   }
17506                 continue;
17507
17508               case STT_FUNC:
17509                 /* Ignore function symbols.  */
17510                 continue;
17511
17512               default:
17513                 break;
17514               }
17515
17516             switch (ELF_ST_BIND (sym->st_info))
17517               {
17518               case STB_GLOBAL:
17519                 if (saved_sym == NULL
17520                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
17521                   saved_sym = sym;
17522                 break;
17523
17524               case STB_LOCAL:
17525                 if (saved_sym == NULL)
17526                   saved_sym = sym;
17527                 break;
17528
17529               default:
17530                 break;
17531               }
17532           }
17533         else
17534           {
17535             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
17536               continue;
17537
17538             saved_sym = sym;
17539             break;
17540           }
17541       }
17542
17543   if (saved_sym && pname)
17544     * pname = strtab + saved_sym->st_name;
17545
17546   return saved_sym;
17547 }
17548
17549 static bfd_boolean
17550 print_gnu_build_attribute_description (Elf_Internal_Note *  pnote,
17551                                        Filedata *           filedata)
17552 {
17553   static unsigned long  global_offset = 0;
17554   static unsigned long  global_end = 0;
17555   static unsigned long  func_offset = 0;
17556   static unsigned long  func_end = 0;
17557
17558   Elf_Internal_Sym *    sym;
17559   const char *          name;
17560   unsigned long         start;
17561   unsigned long         end;
17562   bfd_boolean           is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
17563
17564   switch (pnote->descsz)
17565     {
17566     case 0:
17567       /* A zero-length description means that the range of
17568          the previous note of the same type should be used.  */
17569       if (is_open_attr)
17570         {
17571           if (global_end > global_offset)
17572             printf (_("    Applies to region from %#lx to %#lx\n"),
17573                     global_offset, global_end);
17574           else
17575             printf (_("    Applies to region from %#lx\n"), global_offset);
17576         }
17577       else
17578         {
17579           if (func_end > func_offset)
17580             printf (_("    Applies to region from %#lx to %#lx\n"), func_offset, func_end);
17581           else
17582             printf (_("    Applies to region from %#lx\n"), func_offset);
17583         }
17584       return TRUE;
17585
17586     case 4:
17587       start = byte_get ((unsigned char *) pnote->descdata, 4);
17588       end = 0;
17589       break;
17590
17591     case 8:
17592       if (is_32bit_elf)
17593         {
17594           /* FIXME: We should check that version 3+ notes are being used here...  */
17595           start = byte_get ((unsigned char *) pnote->descdata, 4);
17596           end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17597         }
17598       else
17599         {
17600           start = byte_get ((unsigned char *) pnote->descdata, 8);
17601           end = 0;
17602         }
17603       break;
17604
17605     case 16:
17606       start = byte_get ((unsigned char *) pnote->descdata, 8);
17607       end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
17608       break;
17609
17610     default:
17611       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
17612       printf (_("    <invalid descsz>"));
17613       return FALSE;
17614     }
17615
17616   name = NULL;
17617   sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
17618
17619   if (end == 0 && sym != NULL && sym->st_size > 0)
17620     end = start + sym->st_size;
17621
17622   if (is_open_attr)
17623     {
17624       /* FIXME: Need to properly allow for section alignment.  16 is just the alignment used on x86_64.  */
17625       if (global_end > 0 && start > BFD_ALIGN (global_end, 16))
17626         warn (_("Gap in build notes detected from %#lx to %#lx\n"),
17627               global_end + 1, start - 1);
17628
17629       printf (_("    Applies to region from %#lx"), start);
17630       global_offset = start;
17631
17632       if (end)
17633         {
17634           printf (_(" to %#lx"), end);
17635           global_end = end;
17636         }
17637     }
17638   else
17639     {
17640       printf (_("    Applies to region from %#lx"), start);
17641       func_offset = start;
17642
17643       if (end)
17644         {
17645           printf (_(" to %#lx"), end);
17646           func_end = end;
17647         }
17648     }
17649
17650   if (sym && name)
17651     printf (_(" (%s)"), name);
17652
17653   printf ("\n");
17654   return TRUE;
17655 }
17656
17657 static bfd_boolean
17658 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
17659 {
17660   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
17661   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
17662   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
17663   char         name_type;
17664   char         name_attribute;
17665   const char * expected_types;
17666   const char * name = pnote->namedata;
17667   const char * text;
17668   signed int   left;
17669
17670   if (name == NULL || pnote->namesz < 2)
17671     {
17672       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17673       print_symbol (-20, _("  <corrupt name>"));
17674       return FALSE;
17675     }
17676
17677   if (do_wide)
17678     left = 28;
17679   else
17680     left = 20;
17681
17682   /* Version 2 of the spec adds a "GA" prefix to the name field.  */
17683   if (name[0] == 'G' && name[1] == 'A')
17684     {
17685       if (pnote->namesz < 4)
17686         {
17687           error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17688           print_symbol (-20, _("  <corrupt name>"));
17689           return FALSE;
17690         }
17691
17692       printf ("GA");
17693       name += 2;
17694       left -= 2;
17695     }
17696
17697   switch ((name_type = * name))
17698     {
17699     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17700     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17701     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17702     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17703       printf ("%c", * name);
17704       left --;
17705       break;
17706     default:
17707       error (_("unrecognised attribute type in name field: %d\n"), name_type);
17708       print_symbol (-20, _("<unknown name type>"));
17709       return FALSE;
17710     }
17711
17712   ++ name;
17713   text = NULL;
17714
17715   switch ((name_attribute = * name))
17716     {
17717     case GNU_BUILD_ATTRIBUTE_VERSION:
17718       text = _("<version>");
17719       expected_types = string_expected;
17720       ++ name;
17721       break;
17722     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17723       text = _("<stack prot>");
17724       expected_types = "!+*";
17725       ++ name;
17726       break;
17727     case GNU_BUILD_ATTRIBUTE_RELRO:
17728       text = _("<relro>");
17729       expected_types = bool_expected;
17730       ++ name;
17731       break;
17732     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
17733       text = _("<stack size>");
17734       expected_types = number_expected;
17735       ++ name;
17736       break;
17737     case GNU_BUILD_ATTRIBUTE_TOOL:
17738       text = _("<tool>");
17739       expected_types = string_expected;
17740       ++ name;
17741       break;
17742     case GNU_BUILD_ATTRIBUTE_ABI:
17743       text = _("<ABI>");
17744       expected_types = "$*";
17745       ++ name;
17746       break;
17747     case GNU_BUILD_ATTRIBUTE_PIC:
17748       text = _("<PIC>");
17749       expected_types = number_expected;
17750       ++ name;
17751       break;
17752     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
17753       text = _("<short enum>");
17754       expected_types = bool_expected;
17755       ++ name;
17756       break;
17757     default:
17758       if (ISPRINT (* name))
17759         {
17760           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
17761
17762           if (len > left && ! do_wide)
17763             len = left;
17764           printf ("%.*s:", len, name);
17765           left -= len;
17766           name += len;
17767         }
17768       else
17769         {
17770           static char tmpbuf [128];
17771
17772           error (_("unrecognised byte in name field: %d\n"), * name);
17773           sprintf (tmpbuf, _("<unknown:_%d>"), * name);
17774           text = tmpbuf;
17775           name ++;
17776         }
17777       expected_types = "*$!+";
17778       break;
17779     }
17780
17781   if (text)
17782     left -= printf ("%s", text);
17783
17784   if (strchr (expected_types, name_type) == NULL)
17785     warn (_("attribute does not have an expected type (%c)\n"), name_type);
17786
17787   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
17788     {
17789       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17790              (unsigned long) pnote->namesz,
17791              (long) (name - pnote->namedata));
17792       return FALSE;
17793     }
17794
17795   if (left < 1 && ! do_wide)
17796     return TRUE;
17797
17798   switch (name_type)
17799     {
17800     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17801       {
17802         unsigned int        bytes;
17803         unsigned long long  val = 0;
17804         unsigned int        shift = 0;
17805         char *              decoded = NULL;
17806
17807         bytes = pnote->namesz - (name - pnote->namedata);
17808         if (bytes > 0)
17809           /* The -1 is because the name field is always 0 terminated, and we
17810              want to be able to ensure that the shift in the while loop below
17811              will not overflow.  */
17812           -- bytes;
17813
17814         if (bytes > sizeof (val))
17815           {
17816             error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17817                    bytes);
17818             bytes = sizeof (val);
17819           }
17820         /* We do not bother to warn if bytes == 0 as this can
17821            happen with some early versions of the gcc plugin.  */
17822
17823         while (bytes --)
17824           {
17825             unsigned long byte = (* name ++) & 0xff;
17826
17827             val |= byte << shift;
17828             shift += 8;
17829           }
17830
17831         switch (name_attribute)
17832           {
17833           case GNU_BUILD_ATTRIBUTE_PIC:
17834             switch (val)
17835               {
17836               case 0: decoded = "static"; break;
17837               case 1: decoded = "pic"; break;
17838               case 2: decoded = "PIC"; break;
17839               case 3: decoded = "pie"; break;
17840               case 4: decoded = "PIE"; break;
17841               default: break;
17842               }
17843             break;
17844           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17845             switch (val)
17846               {
17847                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
17848               case 0: decoded = "off"; break;
17849               case 1: decoded = "on"; break;
17850               case 2: decoded = "all"; break;
17851               case 3: decoded = "strong"; break;
17852               case 4: decoded = "explicit"; break;
17853               default: break;
17854               }
17855             break;
17856           default:
17857             break;
17858           }
17859
17860         if (decoded != NULL)
17861           {
17862             print_symbol (-left, decoded);
17863             left = 0;
17864           }
17865         else if (val == 0)
17866           {
17867             printf ("0x0");
17868             left -= 3;
17869           }
17870         else
17871           {
17872             if (do_wide)
17873               left -= printf ("0x%llx", val);
17874             else
17875               left -= printf ("0x%-.*llx", left, val);
17876           }
17877       }
17878       break;
17879     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17880       left -= print_symbol (- left, name);
17881       break;
17882     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17883       left -= print_symbol (- left, "true");
17884       break;
17885     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17886       left -= print_symbol (- left, "false");
17887       break;
17888     }
17889
17890   if (do_wide && left > 0)
17891     printf ("%-*s", left, " ");
17892
17893   return TRUE;
17894 }
17895
17896 /* Note that by the ELF standard, the name field is already null byte
17897    terminated, and namesz includes the terminating null byte.
17898    I.E. the value of namesz for the name "FSF" is 4.
17899
17900    If the value of namesz is zero, there is no name present.  */
17901
17902 static bfd_boolean
17903 process_note (Elf_Internal_Note *  pnote,
17904               Filedata *           filedata)
17905 {
17906   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
17907   const char * nt;
17908
17909   if (pnote->namesz == 0)
17910     /* If there is no note name, then use the default set of
17911        note type strings.  */
17912     nt = get_note_type (filedata, pnote->type);
17913
17914   else if (const_strneq (pnote->namedata, "GNU"))
17915     /* GNU-specific object file notes.  */
17916     nt = get_gnu_elf_note_type (pnote->type);
17917
17918   else if (const_strneq (pnote->namedata, "FreeBSD"))
17919     /* FreeBSD-specific core file notes.  */
17920     nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
17921
17922   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
17923     /* NetBSD-specific core file notes.  */
17924     nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
17925
17926   else if (const_strneq (pnote->namedata, "NetBSD"))
17927     /* NetBSD-specific core file notes.  */
17928     return process_netbsd_elf_note (pnote);
17929
17930   else if (strneq (pnote->namedata, "SPU/", 4))
17931     {
17932       /* SPU-specific core file notes.  */
17933       nt = pnote->namedata + 4;
17934       name = "SPU";
17935     }
17936
17937   else if (const_strneq (pnote->namedata, "IPF/VMS"))
17938     /* VMS/ia64-specific file notes.  */
17939     nt = get_ia64_vms_note_type (pnote->type);
17940
17941   else if (const_strneq (pnote->namedata, "stapsdt"))
17942     nt = get_stapsdt_note_type (pnote->type);
17943
17944   else
17945     /* Don't recognize this note name; just use the default set of
17946        note type strings.  */
17947     nt = get_note_type (filedata, pnote->type);
17948
17949   printf ("  ");
17950
17951   if (((const_strneq (pnote->namedata, "GA")
17952         && strchr ("*$!+", pnote->namedata[2]) != NULL)
17953        || strchr ("*$!+", pnote->namedata[0]) != NULL)
17954       && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17955           || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
17956     print_gnu_build_attribute_name (pnote);
17957   else
17958     print_symbol (-20, name);
17959
17960   if (do_wide)
17961     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
17962   else
17963     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
17964
17965   if (const_strneq (pnote->namedata, "IPF/VMS"))
17966     return print_ia64_vms_note (pnote);
17967   else if (const_strneq (pnote->namedata, "GNU"))
17968     return print_gnu_note (filedata, pnote);
17969   else if (const_strneq (pnote->namedata, "stapsdt"))
17970     return print_stapsdt_note (pnote);
17971   else if (const_strneq (pnote->namedata, "CORE"))
17972     return print_core_note (pnote);
17973   else if (((const_strneq (pnote->namedata, "GA")
17974              && strchr ("*$!+", pnote->namedata[2]) != NULL)
17975             || strchr ("*$!+", pnote->namedata[0]) != NULL)
17976            && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17977                || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
17978     return print_gnu_build_attribute_description (pnote, filedata);
17979
17980   if (pnote->descsz)
17981     {
17982       unsigned long i;
17983
17984       printf (_("   description data: "));
17985       for (i = 0; i < pnote->descsz; i++)
17986         printf ("%02x ", pnote->descdata[i]);
17987       if (!do_wide)
17988         printf ("\n");
17989     }
17990
17991   if (do_wide)
17992     printf ("\n");
17993
17994   return TRUE;
17995 }
17996
17997 static bfd_boolean
17998 process_notes_at (Filedata *           filedata,
17999                   Elf_Internal_Shdr *  section,
18000                   bfd_vma              offset,
18001                   bfd_vma              length,
18002                   bfd_vma              align)
18003 {
18004   Elf_External_Note * pnotes;
18005   Elf_External_Note * external;
18006   char *              end;
18007   bfd_boolean         res = TRUE;
18008
18009   if (length <= 0)
18010     return FALSE;
18011
18012   if (section)
18013     {
18014       pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
18015       if (pnotes)
18016         {
18017           if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
18018             return FALSE;
18019         }
18020     }
18021   else
18022     pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18023                                              _("notes"));
18024
18025   if (pnotes == NULL)
18026     return FALSE;
18027
18028   external = pnotes;
18029
18030   if (section)
18031     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
18032   else
18033     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18034             (unsigned long) offset, (unsigned long) length);
18035
18036   /* NB: Some note sections may have alignment value of 0 or 1.  gABI
18037      specifies that notes should be aligned to 4 bytes in 32-bit
18038      objects and to 8 bytes in 64-bit objects.  As a Linux extension,
18039      we also support 4 byte alignment in 64-bit objects.  If section
18040      alignment is less than 4, we treate alignment as 4 bytes.   */
18041   if (align < 4)
18042     align = 4;
18043   else if (align != 4 && align != 8)
18044     {
18045       warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18046             (long) align);
18047       return FALSE;
18048     }
18049
18050   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18051
18052   end = (char *) pnotes + length;
18053   while ((char *) external < end)
18054     {
18055       Elf_Internal_Note inote;
18056       size_t min_notesz;
18057       char * next;
18058       char * temp = NULL;
18059       size_t data_remaining = end - (char *) external;
18060
18061       if (!is_ia64_vms (filedata))
18062         {
18063           /* PR binutils/15191
18064              Make sure that there is enough data to read.  */
18065           min_notesz = offsetof (Elf_External_Note, name);
18066           if (data_remaining < min_notesz)
18067             {
18068               warn (ngettext ("Corrupt note: only %ld byte remains, "
18069                               "not enough for a full note\n",
18070                               "Corrupt note: only %ld bytes remain, "
18071                               "not enough for a full note\n",
18072                               data_remaining),
18073                     (long) data_remaining);
18074               break;
18075             }
18076           data_remaining -= min_notesz;
18077
18078           inote.type     = BYTE_GET (external->type);
18079           inote.namesz   = BYTE_GET (external->namesz);
18080           inote.namedata = external->name;
18081           inote.descsz   = BYTE_GET (external->descsz);
18082           inote.descdata = ((char *) external
18083                             + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
18084           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18085           next = ((char *) external
18086                   + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
18087         }
18088       else
18089         {
18090           Elf64_External_VMS_Note *vms_external;
18091
18092           /* PR binutils/15191
18093              Make sure that there is enough data to read.  */
18094           min_notesz = offsetof (Elf64_External_VMS_Note, name);
18095           if (data_remaining < min_notesz)
18096             {
18097               warn (ngettext ("Corrupt note: only %ld byte remains, "
18098                               "not enough for a full note\n",
18099                               "Corrupt note: only %ld bytes remain, "
18100                               "not enough for a full note\n",
18101                               data_remaining),
18102                     (long) data_remaining);
18103               break;
18104             }
18105           data_remaining -= min_notesz;
18106
18107           vms_external = (Elf64_External_VMS_Note *) external;
18108           inote.type     = BYTE_GET (vms_external->type);
18109           inote.namesz   = BYTE_GET (vms_external->namesz);
18110           inote.namedata = vms_external->name;
18111           inote.descsz   = BYTE_GET (vms_external->descsz);
18112           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
18113           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18114           next = inote.descdata + align_power (inote.descsz, 3);
18115         }
18116
18117       /* PR 17531: file: 3443835e.  */
18118       /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
18119       if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
18120           || (size_t) (inote.descdata - inote.namedata) > data_remaining
18121           || (size_t) (next - inote.descdata) < inote.descsz
18122           || ((size_t) (next - inote.descdata)
18123               > data_remaining - (size_t) (inote.descdata - inote.namedata)))
18124         {
18125           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18126                 (unsigned long) ((char *) external - (char *) pnotes));
18127           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18128                 inote.type, inote.namesz, inote.descsz, (int) align);
18129           break;
18130         }
18131
18132       external = (Elf_External_Note *) next;
18133
18134       /* Verify that name is null terminated.  It appears that at least
18135          one version of Linux (RedHat 6.0) generates corefiles that don't
18136          comply with the ELF spec by failing to include the null byte in
18137          namesz.  */
18138       if (inote.namedata[inote.namesz - 1] != '\0')
18139         {
18140           if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
18141             {
18142               temp = (char *) malloc (inote.namesz + 1);
18143               if (temp == NULL)
18144                 {
18145                   error (_("Out of memory allocating space for inote name\n"));
18146                   res = FALSE;
18147                   break;
18148                 }
18149
18150               memcpy (temp, inote.namedata, inote.namesz);
18151               inote.namedata = temp;
18152             }
18153           inote.namedata[inote.namesz] = 0;
18154         }
18155
18156       if (! process_note (& inote, filedata))
18157         res = FALSE;
18158
18159       if (temp != NULL)
18160         {
18161           free (temp);
18162           temp = NULL;
18163         }
18164     }
18165
18166   free (pnotes);
18167
18168   return res;
18169 }
18170
18171 static bfd_boolean
18172 process_corefile_note_segments (Filedata * filedata)
18173 {
18174   Elf_Internal_Phdr * segment;
18175   unsigned int i;
18176   bfd_boolean res = TRUE;
18177
18178   if (! get_program_headers (filedata))
18179     return TRUE;
18180
18181   for (i = 0, segment = filedata->program_headers;
18182        i < filedata->file_header.e_phnum;
18183        i++, segment++)
18184     {
18185       if (segment->p_type == PT_NOTE)
18186         if (! process_notes_at (filedata, NULL,
18187                                 (bfd_vma) segment->p_offset,
18188                                 (bfd_vma) segment->p_filesz,
18189                                 (bfd_vma) segment->p_align))
18190           res = FALSE;
18191     }
18192
18193   return res;
18194 }
18195
18196 static bfd_boolean
18197 process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
18198 {
18199   Elf_External_Note * pnotes;
18200   Elf_External_Note * external;
18201   char * end;
18202   bfd_boolean res = TRUE;
18203
18204   if (length <= 0)
18205     return FALSE;
18206
18207   pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18208                                            _("v850 notes"));
18209   if (pnotes == NULL)
18210     return FALSE;
18211
18212   external = pnotes;
18213   end = (char*) pnotes + length;
18214
18215   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18216           (unsigned long) offset, (unsigned long) length);
18217
18218   while ((char *) external + sizeof (Elf_External_Note) < end)
18219     {
18220       Elf_External_Note * next;
18221       Elf_Internal_Note inote;
18222
18223       inote.type     = BYTE_GET (external->type);
18224       inote.namesz   = BYTE_GET (external->namesz);
18225       inote.namedata = external->name;
18226       inote.descsz   = BYTE_GET (external->descsz);
18227       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
18228       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18229
18230       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
18231         {
18232           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
18233           inote.descdata = inote.namedata;
18234           inote.namesz   = 0;
18235         }
18236
18237       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
18238
18239       if (   ((char *) next > end)
18240           || ((char *) next <  (char *) pnotes))
18241         {
18242           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18243                 (unsigned long) ((char *) external - (char *) pnotes));
18244           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18245                 inote.type, inote.namesz, inote.descsz);
18246           break;
18247         }
18248
18249       external = next;
18250
18251       /* Prevent out-of-bounds indexing.  */
18252       if (   inote.namedata + inote.namesz > end
18253           || inote.namedata + inote.namesz < inote.namedata)
18254         {
18255           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18256                 (unsigned long) ((char *) external - (char *) pnotes));
18257           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18258                 inote.type, inote.namesz, inote.descsz);
18259           break;
18260         }
18261
18262       printf ("  %s: ", get_v850_elf_note_type (inote.type));
18263
18264       if (! print_v850_note (& inote))
18265         {
18266           res = FALSE;
18267           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18268                   inote.namesz, inote.descsz);
18269         }
18270     }
18271
18272   free (pnotes);
18273
18274   return res;
18275 }
18276
18277 static bfd_boolean
18278 process_note_sections (Filedata * filedata)
18279 {
18280   Elf_Internal_Shdr * section;
18281   unsigned long i;
18282   unsigned int n = 0;
18283   bfd_boolean res = TRUE;
18284
18285   for (i = 0, section = filedata->section_headers;
18286        i < filedata->file_header.e_shnum && section != NULL;
18287        i++, section++)
18288     {
18289       if (section->sh_type == SHT_NOTE)
18290         {
18291           if (! process_notes_at (filedata, section,
18292                                   (bfd_vma) section->sh_offset,
18293                                   (bfd_vma) section->sh_size,
18294                                   (bfd_vma) section->sh_addralign))
18295             res = FALSE;
18296           n++;
18297         }
18298
18299       if ((   filedata->file_header.e_machine == EM_V800
18300            || filedata->file_header.e_machine == EM_V850
18301            || filedata->file_header.e_machine == EM_CYGNUS_V850)
18302           && section->sh_type == SHT_RENESAS_INFO)
18303         {
18304           if (! process_v850_notes (filedata,
18305                                     (bfd_vma) section->sh_offset,
18306                                     (bfd_vma) section->sh_size))
18307             res = FALSE;
18308           n++;
18309         }
18310     }
18311
18312   if (n == 0)
18313     /* Try processing NOTE segments instead.  */
18314     return process_corefile_note_segments (filedata);
18315
18316   return res;
18317 }
18318
18319 static bfd_boolean
18320 process_notes (Filedata * filedata)
18321 {
18322   /* If we have not been asked to display the notes then do nothing.  */
18323   if (! do_notes)
18324     return TRUE;
18325
18326   if (filedata->file_header.e_type != ET_CORE)
18327     return process_note_sections (filedata);
18328
18329   /* No program headers means no NOTE segment.  */
18330   if (filedata->file_header.e_phnum > 0)
18331     return process_corefile_note_segments (filedata);
18332
18333   printf (_("No note segments present in the core file.\n"));
18334   return TRUE;
18335 }
18336
18337 static unsigned char *
18338 display_public_gnu_attributes (unsigned char * start,
18339                                const unsigned char * const end)
18340 {
18341   printf (_("  Unknown GNU attribute: %s\n"), start);
18342
18343   start += strnlen ((char *) start, end - start);
18344   display_raw_attribute (start, end);
18345
18346   return (unsigned char *) end;
18347 }
18348
18349 static unsigned char *
18350 display_generic_attribute (unsigned char * start,
18351                            unsigned int tag,
18352                            const unsigned char * const end)
18353 {
18354   if (tag == 0)
18355     return (unsigned char *) end;
18356
18357   return display_tag_value (tag, start, end);
18358 }
18359
18360 static bfd_boolean
18361 process_arch_specific (Filedata * filedata)
18362 {
18363   if (! do_arch)
18364     return TRUE;
18365
18366   switch (filedata->file_header.e_machine)
18367     {
18368     case EM_ARC:
18369     case EM_ARC_COMPACT:
18370     case EM_ARC_COMPACT2:
18371       return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
18372                                  display_arc_attribute,
18373                                  display_generic_attribute);
18374     case EM_ARM:
18375       return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
18376                                  display_arm_attribute,
18377                                  display_generic_attribute);
18378
18379     case EM_MIPS:
18380     case EM_MIPS_RS3_LE:
18381       return process_mips_specific (filedata);
18382
18383     case EM_MSP430:
18384      return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
18385                                 display_msp430x_attribute,
18386                                 display_generic_attribute);
18387
18388     case EM_NDS32:
18389       return process_nds32_specific (filedata);
18390
18391     case EM_PPC:
18392     case EM_PPC64:
18393       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18394                                  display_power_gnu_attribute);
18395
18396     case EM_S390:
18397     case EM_S390_OLD:
18398       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18399                                  display_s390_gnu_attribute);
18400
18401     case EM_SPARC:
18402     case EM_SPARC32PLUS:
18403     case EM_SPARCV9:
18404       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18405                                  display_sparc_gnu_attribute);
18406
18407     case EM_TI_C6000:
18408       return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
18409                                  display_tic6x_attribute,
18410                                  display_generic_attribute);
18411
18412     default:
18413       return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
18414                                  display_public_gnu_attributes,
18415                                  display_generic_attribute);
18416     }
18417 }
18418
18419 static bfd_boolean
18420 get_file_header (Filedata * filedata)
18421 {
18422   /* Read in the identity array.  */
18423   if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
18424     return FALSE;
18425
18426   /* Determine how to read the rest of the header.  */
18427   switch (filedata->file_header.e_ident[EI_DATA])
18428     {
18429     default:
18430     case ELFDATANONE:
18431     case ELFDATA2LSB:
18432       byte_get = byte_get_little_endian;
18433       byte_put = byte_put_little_endian;
18434       break;
18435     case ELFDATA2MSB:
18436       byte_get = byte_get_big_endian;
18437       byte_put = byte_put_big_endian;
18438       break;
18439     }
18440
18441   /* For now we only support 32 bit and 64 bit ELF files.  */
18442   is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
18443
18444   /* Read in the rest of the header.  */
18445   if (is_32bit_elf)
18446     {
18447       Elf32_External_Ehdr ehdr32;
18448
18449       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
18450         return FALSE;
18451
18452       filedata->file_header.e_type      = BYTE_GET (ehdr32.e_type);
18453       filedata->file_header.e_machine   = BYTE_GET (ehdr32.e_machine);
18454       filedata->file_header.e_version   = BYTE_GET (ehdr32.e_version);
18455       filedata->file_header.e_entry     = BYTE_GET (ehdr32.e_entry);
18456       filedata->file_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
18457       filedata->file_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
18458       filedata->file_header.e_flags     = BYTE_GET (ehdr32.e_flags);
18459       filedata->file_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
18460       filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
18461       filedata->file_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
18462       filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
18463       filedata->file_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
18464       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
18465     }
18466   else
18467     {
18468       Elf64_External_Ehdr ehdr64;
18469
18470       /* If we have been compiled with sizeof (bfd_vma) == 4, then
18471          we will not be able to cope with the 64bit data found in
18472          64 ELF files.  Detect this now and abort before we start
18473          overwriting things.  */
18474       if (sizeof (bfd_vma) < 8)
18475         {
18476           error (_("This instance of readelf has been built without support for a\n\
18477 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18478           return FALSE;
18479         }
18480
18481       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
18482         return FALSE;
18483
18484       filedata->file_header.e_type      = BYTE_GET (ehdr64.e_type);
18485       filedata->file_header.e_machine   = BYTE_GET (ehdr64.e_machine);
18486       filedata->file_header.e_version   = BYTE_GET (ehdr64.e_version);
18487       filedata->file_header.e_entry     = BYTE_GET (ehdr64.e_entry);
18488       filedata->file_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
18489       filedata->file_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
18490       filedata->file_header.e_flags     = BYTE_GET (ehdr64.e_flags);
18491       filedata->file_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
18492       filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
18493       filedata->file_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
18494       filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
18495       filedata->file_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
18496       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
18497     }
18498
18499   if (filedata->file_header.e_shoff)
18500     {
18501       /* There may be some extensions in the first section header.  Don't
18502          bomb if we can't read it.  */
18503       if (is_32bit_elf)
18504         get_32bit_section_headers (filedata, TRUE);
18505       else
18506         get_64bit_section_headers (filedata, TRUE);
18507     }
18508
18509   return TRUE;
18510 }
18511
18512 static void
18513 close_file (Filedata * filedata)
18514 {
18515   if (filedata)
18516     {
18517       if (filedata->handle)
18518         fclose (filedata->handle);
18519       free (filedata);
18520     }
18521 }
18522
18523 void
18524 close_debug_file (void * data)
18525 {
18526   close_file ((Filedata *) data);
18527 }
18528
18529 static Filedata *
18530 open_file (const char * pathname)
18531 {
18532   struct stat  statbuf;
18533   Filedata *   filedata = NULL;
18534
18535   if (stat (pathname, & statbuf) < 0
18536       || ! S_ISREG (statbuf.st_mode))
18537     goto fail;
18538
18539   filedata = calloc (1, sizeof * filedata);
18540   if (filedata == NULL)
18541     goto fail;
18542
18543   filedata->handle = fopen (pathname, "rb");
18544   if (filedata->handle == NULL)
18545     goto fail;
18546
18547   filedata->file_size = (bfd_size_type) statbuf.st_size;
18548   filedata->file_name = pathname;
18549
18550   if (! get_file_header (filedata))
18551     goto fail;
18552
18553   if (filedata->file_header.e_shoff)
18554     {
18555       bfd_boolean res;
18556
18557       /* Read the section headers again, this time for real.  */
18558       if (is_32bit_elf)
18559         res = get_32bit_section_headers (filedata, FALSE);
18560       else
18561         res = get_64bit_section_headers (filedata, FALSE);
18562
18563       if (!res)
18564         goto fail;
18565     }
18566
18567   return filedata;
18568
18569  fail:
18570   if (filedata)
18571     {
18572       if (filedata->handle)
18573         fclose (filedata->handle);
18574       free (filedata);
18575     }
18576   return NULL;
18577 }
18578
18579 void *
18580 open_debug_file (const char * pathname)
18581 {
18582   return open_file (pathname);
18583 }
18584
18585 /* Process one ELF object file according to the command line options.
18586    This file may actually be stored in an archive.  The file is
18587    positioned at the start of the ELF object.  Returns TRUE if no
18588    problems were encountered, FALSE otherwise.  */
18589
18590 static bfd_boolean
18591 process_object (Filedata * filedata)
18592 {
18593   Filedata * separates;
18594   unsigned int i;
18595   bfd_boolean res = TRUE;
18596
18597   if (! get_file_header (filedata))
18598     {
18599       error (_("%s: Failed to read file header\n"), filedata->file_name);
18600       return FALSE;
18601     }
18602
18603   /* Initialise per file variables.  */
18604   for (i = ARRAY_SIZE (version_info); i--;)
18605     version_info[i] = 0;
18606
18607   for (i = ARRAY_SIZE (dynamic_info); i--;)
18608     dynamic_info[i] = 0;
18609   dynamic_info_DT_GNU_HASH = 0;
18610
18611   /* Process the file.  */
18612   if (show_name)
18613     printf (_("\nFile: %s\n"), filedata->file_name);
18614
18615   /* Initialise the dump_sects array from the cmdline_dump_sects array.
18616      Note we do this even if cmdline_dump_sects is empty because we
18617      must make sure that the dump_sets array is zeroed out before each
18618      object file is processed.  */
18619   if (filedata->num_dump_sects > cmdline.num_dump_sects)
18620     memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
18621
18622   if (cmdline.num_dump_sects > 0)
18623     {
18624       if (filedata->num_dump_sects == 0)
18625         /* A sneaky way of allocating the dump_sects array.  */
18626         request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
18627
18628       assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
18629       memcpy (filedata->dump_sects, cmdline.dump_sects,
18630               cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
18631     }
18632
18633   if (! process_file_header (filedata))
18634     return FALSE;
18635
18636   if (! process_section_headers (filedata))
18637     {
18638       /* Without loaded section headers we cannot process lots of things.  */
18639       do_unwind = do_version = do_dump = do_arch = FALSE;
18640
18641       if (! do_using_dynamic)
18642         do_syms = do_dyn_syms = do_reloc = FALSE;
18643     }
18644
18645   if (! process_section_groups (filedata))
18646     /* Without loaded section groups we cannot process unwind.  */
18647     do_unwind = FALSE;
18648
18649   if (process_program_headers (filedata))
18650     process_dynamic_section (filedata);
18651   else
18652     res = FALSE;
18653
18654   if (! process_relocs (filedata))
18655     res = FALSE;
18656
18657   if (! process_unwind (filedata))
18658     res = FALSE;
18659
18660   if (! process_symbol_table (filedata))
18661     res = FALSE;
18662
18663   if (! process_syminfo (filedata))
18664     res = FALSE;
18665
18666   if (! process_version_sections (filedata))
18667     res = FALSE;
18668
18669   if (filedata->file_header.e_shstrndx != SHN_UNDEF)
18670     separates = load_separate_debug_file (filedata, filedata->file_name);
18671   else
18672     separates = NULL;
18673
18674   if (! process_section_contents (filedata))
18675     res = FALSE;
18676
18677   if (separates)
18678     {
18679       if (! process_section_headers (separates))
18680         res = FALSE;
18681       else if (! process_section_contents (separates))
18682         res = FALSE;
18683     }
18684
18685   if (! process_notes (filedata))
18686     res = FALSE;
18687
18688   if (! process_gnu_liblist (filedata))
18689     res = FALSE;
18690
18691   if (! process_arch_specific (filedata))
18692     res = FALSE;
18693
18694   free (filedata->program_headers);
18695   filedata->program_headers = NULL;
18696
18697   free (filedata->section_headers);
18698   filedata->section_headers = NULL;
18699
18700   free (filedata->string_table);
18701   filedata->string_table = NULL;
18702   filedata->string_table_length = 0;
18703
18704   if (dynamic_strings)
18705     {
18706       free (dynamic_strings);
18707       dynamic_strings = NULL;
18708       dynamic_strings_length = 0;
18709     }
18710
18711   if (dynamic_symbols)
18712     {
18713       free (dynamic_symbols);
18714       dynamic_symbols = NULL;
18715       num_dynamic_syms = 0;
18716     }
18717
18718   if (dynamic_syminfo)
18719     {
18720       free (dynamic_syminfo);
18721       dynamic_syminfo = NULL;
18722     }
18723
18724   if (dynamic_section)
18725     {
18726       free (dynamic_section);
18727       dynamic_section = NULL;
18728     }
18729
18730   if (section_headers_groups)
18731     {
18732       free (section_headers_groups);
18733       section_headers_groups = NULL;
18734     }
18735
18736   if (section_groups)
18737     {
18738       struct group_list * g;
18739       struct group_list * next;
18740
18741       for (i = 0; i < group_count; i++)
18742         {
18743           for (g = section_groups [i].root; g != NULL; g = next)
18744             {
18745               next = g->next;
18746               free (g);
18747             }
18748         }
18749
18750       free (section_groups);
18751       section_groups = NULL;
18752     }
18753
18754   free_debug_memory ();
18755
18756   return res;
18757 }
18758
18759 /* Process an ELF archive.
18760    On entry the file is positioned just after the ARMAG string.
18761    Returns TRUE upon success, FALSE otherwise.  */
18762
18763 static bfd_boolean
18764 process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
18765 {
18766   struct archive_info arch;
18767   struct archive_info nested_arch;
18768   size_t got;
18769   bfd_boolean ret = TRUE;
18770
18771   show_name = TRUE;
18772
18773   /* The ARCH structure is used to hold information about this archive.  */
18774   arch.file_name = NULL;
18775   arch.file = NULL;
18776   arch.index_array = NULL;
18777   arch.sym_table = NULL;
18778   arch.longnames = NULL;
18779
18780   /* The NESTED_ARCH structure is used as a single-item cache of information
18781      about a nested archive (when members of a thin archive reside within
18782      another regular archive file).  */
18783   nested_arch.file_name = NULL;
18784   nested_arch.file = NULL;
18785   nested_arch.index_array = NULL;
18786   nested_arch.sym_table = NULL;
18787   nested_arch.longnames = NULL;
18788
18789   if (setup_archive (&arch, filedata->file_name, filedata->handle,
18790                      is_thin_archive, do_archive_index) != 0)
18791     {
18792       ret = FALSE;
18793       goto out;
18794     }
18795
18796   if (do_archive_index)
18797     {
18798       if (arch.sym_table == NULL)
18799         error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
18800       else
18801         {
18802           unsigned long i, l;
18803           unsigned long current_pos;
18804
18805           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18806                   filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
18807
18808           current_pos = ftell (filedata->handle);
18809
18810           for (i = l = 0; i < arch.index_num; i++)
18811             {
18812               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
18813                 {
18814                   char * member_name;
18815
18816                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
18817
18818                   if (member_name != NULL)
18819                     {
18820                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
18821
18822                       if (qualified_name != NULL)
18823                         {
18824                           printf (_("Contents of binary %s at offset "), qualified_name);
18825                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
18826                           putchar ('\n');
18827                           free (qualified_name);
18828                         }
18829                     }
18830                 }
18831
18832               if (l >= arch.sym_size)
18833                 {
18834                   error (_("%s: end of the symbol table reached before the end of the index\n"),
18835                          filedata->file_name);
18836                   ret = FALSE;
18837                   break;
18838                 }
18839               /* PR 17531: file: 0b6630b2.  */
18840               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
18841               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
18842             }
18843
18844           if (arch.uses_64bit_indicies)
18845             l = (l + 7) & ~ 7;
18846           else
18847             l += l & 1;
18848
18849           if (l < arch.sym_size)
18850             {
18851               error (ngettext ("%s: %ld byte remains in the symbol table, "
18852                                "but without corresponding entries in "
18853                                "the index table\n",
18854                                "%s: %ld bytes remain in the symbol table, "
18855                                "but without corresponding entries in "
18856                                "the index table\n",
18857                                arch.sym_size - l),
18858                      filedata->file_name, arch.sym_size - l);
18859               ret = FALSE;
18860             }
18861
18862           if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
18863             {
18864               error (_("%s: failed to seek back to start of object files in the archive\n"),
18865                      filedata->file_name);
18866               ret = FALSE;
18867               goto out;
18868             }
18869         }
18870
18871       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
18872           && !do_segments && !do_header && !do_dump && !do_version
18873           && !do_histogram && !do_debugging && !do_arch && !do_notes
18874           && !do_section_groups && !do_dyn_syms)
18875         {
18876           ret = TRUE; /* Archive index only.  */
18877           goto out;
18878         }
18879     }
18880
18881   while (1)
18882     {
18883       char * name;
18884       size_t namelen;
18885       char * qualified_name;
18886
18887       /* Read the next archive header.  */
18888       if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
18889         {
18890           error (_("%s: failed to seek to next archive header\n"), filedata->file_name);
18891           return FALSE;
18892         }
18893       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
18894       if (got != sizeof arch.arhdr)
18895         {
18896           if (got == 0)
18897             break;
18898           error (_("%s: failed to read archive header\n"), filedata->file_name);
18899           ret = FALSE;
18900           break;
18901         }
18902       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
18903         {
18904           error (_("%s: did not find a valid archive header\n"), arch.file_name);
18905           ret = FALSE;
18906           break;
18907         }
18908
18909       arch.next_arhdr_offset += sizeof arch.arhdr;
18910
18911       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
18912       if (archive_file_size & 01)
18913         ++archive_file_size;
18914
18915       name = get_archive_member_name (&arch, &nested_arch);
18916       if (name == NULL)
18917         {
18918           error (_("%s: bad archive file name\n"), filedata->file_name);
18919           ret = FALSE;
18920           break;
18921         }
18922       namelen = strlen (name);
18923
18924       qualified_name = make_qualified_name (&arch, &nested_arch, name);
18925       if (qualified_name == NULL)
18926         {
18927           error (_("%s: bad archive file name\n"), filedata->file_name);
18928           ret = FALSE;
18929           break;
18930         }
18931
18932       if (is_thin_archive && arch.nested_member_origin == 0)
18933         {
18934           /* This is a proxy for an external member of a thin archive.  */
18935           Filedata * member_filedata;
18936           char * member_file_name = adjust_relative_path
18937             (filedata->file_name, name, namelen);
18938
18939           if (member_file_name == NULL)
18940             {
18941               ret = FALSE;
18942               break;
18943             }
18944
18945           member_filedata = open_file (member_file_name);
18946           if (member_filedata == NULL)
18947             {
18948               error (_("Input file '%s' is not readable.\n"), member_file_name);
18949               free (member_file_name);
18950               ret = FALSE;
18951               break;
18952             }
18953
18954           archive_file_offset = arch.nested_member_origin;
18955           member_filedata->file_name = qualified_name;
18956
18957           if (! process_object (member_filedata))
18958             ret = FALSE;
18959
18960           close_file (member_filedata);
18961           free (member_file_name);
18962         }
18963       else if (is_thin_archive)
18964         {
18965           Filedata thin_filedata;
18966
18967           memset (&thin_filedata, 0, sizeof (thin_filedata));
18968
18969           /* PR 15140: Allow for corrupt thin archives.  */
18970           if (nested_arch.file == NULL)
18971             {
18972               error (_("%s: contains corrupt thin archive: %s\n"),
18973                      filedata->file_name, name);
18974               ret = FALSE;
18975               break;
18976             }
18977
18978           /* This is a proxy for a member of a nested archive.  */
18979           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
18980
18981           /* The nested archive file will have been opened and setup by
18982              get_archive_member_name.  */
18983           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
18984             {
18985               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
18986               ret = FALSE;
18987               break;
18988             }
18989
18990           thin_filedata.handle = nested_arch.file;
18991           thin_filedata.file_name = qualified_name;
18992
18993           if (! process_object (& thin_filedata))
18994             ret = FALSE;
18995         }
18996       else
18997         {
18998           archive_file_offset = arch.next_arhdr_offset;
18999           arch.next_arhdr_offset += archive_file_size;
19000
19001           filedata->file_name = qualified_name;
19002           if (! process_object (filedata))
19003             ret = FALSE;
19004         }
19005
19006       if (filedata->dump_sects != NULL)
19007         {
19008           free (filedata->dump_sects);
19009           filedata->dump_sects = NULL;
19010           filedata->num_dump_sects = 0;
19011         }
19012
19013       free (qualified_name);
19014     }
19015
19016  out:
19017   if (nested_arch.file != NULL)
19018     fclose (nested_arch.file);
19019   release_archive (&nested_arch);
19020   release_archive (&arch);
19021
19022   return ret;
19023 }
19024
19025 static bfd_boolean
19026 process_file (char * file_name)
19027 {
19028   Filedata * filedata = NULL;
19029   struct stat statbuf;
19030   char armag[SARMAG];
19031   bfd_boolean ret = TRUE;
19032
19033   if (stat (file_name, &statbuf) < 0)
19034     {
19035       if (errno == ENOENT)
19036         error (_("'%s': No such file\n"), file_name);
19037       else
19038         error (_("Could not locate '%s'.  System error message: %s\n"),
19039                file_name, strerror (errno));
19040       return FALSE;
19041     }
19042
19043   if (! S_ISREG (statbuf.st_mode))
19044     {
19045       error (_("'%s' is not an ordinary file\n"), file_name);
19046       return FALSE;
19047     }
19048
19049   filedata = calloc (1, sizeof * filedata);
19050   if (filedata == NULL)
19051     {
19052       error (_("Out of memory allocating file data structure\n"));
19053       return FALSE;
19054     }
19055
19056   filedata->file_name = file_name;
19057   filedata->handle = fopen (file_name, "rb");
19058   if (filedata->handle == NULL)
19059     {
19060       error (_("Input file '%s' is not readable.\n"), file_name);
19061       free (filedata);
19062       return FALSE;
19063     }
19064
19065   if (fread (armag, SARMAG, 1, filedata->handle) != 1)
19066     {
19067       error (_("%s: Failed to read file's magic number\n"), file_name);
19068       fclose (filedata->handle);
19069       free (filedata);
19070       return FALSE;
19071     }
19072
19073   filedata->file_size = (bfd_size_type) statbuf.st_size;
19074
19075   if (memcmp (armag, ARMAG, SARMAG) == 0)
19076     {
19077       if (! process_archive (filedata, FALSE))
19078         ret = FALSE;
19079     }
19080   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
19081     {
19082       if ( ! process_archive (filedata, TRUE))
19083         ret = FALSE;
19084     }
19085   else
19086     {
19087       if (do_archive_index)
19088         error (_("File %s is not an archive so its index cannot be displayed.\n"),
19089                file_name);
19090
19091       rewind (filedata->handle);
19092       archive_file_size = archive_file_offset = 0;
19093
19094       if (! process_object (filedata))
19095         ret = FALSE;
19096     }
19097
19098   fclose (filedata->handle);
19099   free (filedata);
19100
19101   return ret;
19102 }
19103
19104 #ifdef SUPPORT_DISASSEMBLY
19105 /* Needed by the i386 disassembler.  For extra credit, someone could
19106    fix this so that we insert symbolic addresses here, esp for GOT/PLT
19107    symbols.  */
19108
19109 void
19110 print_address (unsigned int addr, FILE * outfile)
19111 {
19112   fprintf (outfile,"0x%8.8x", addr);
19113 }
19114
19115 /* Needed by the i386 disassembler.  */
19116
19117 void
19118 db_task_printsym (unsigned int addr)
19119 {
19120   print_address (addr, stderr);
19121 }
19122 #endif
19123
19124 int
19125 main (int argc, char ** argv)
19126 {
19127   int err;
19128
19129 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19130   setlocale (LC_MESSAGES, "");
19131 #endif
19132 #if defined (HAVE_SETLOCALE)
19133   setlocale (LC_CTYPE, "");
19134 #endif
19135   bindtextdomain (PACKAGE, LOCALEDIR);
19136   textdomain (PACKAGE);
19137
19138   expandargv (&argc, &argv);
19139
19140   cmdline.file_name = "<cmdline>";
19141   parse_args (& cmdline, argc, argv);
19142
19143   if (optind < (argc - 1))
19144     show_name = TRUE;
19145   else if (optind >= argc)
19146     {
19147       warn (_("Nothing to do.\n"));
19148       usage (stderr);
19149     }
19150
19151   err = FALSE;
19152   while (optind < argc)
19153     if (! process_file (argv[optind++]))
19154       err = TRUE;
19155
19156   if (cmdline.dump_sects != NULL)
19157     free (cmdline.dump_sects);
19158
19159   return err ? EXIT_FAILURE : EXIT_SUCCESS;
19160 }