binutils/readelf.c

   1 /* readelf.c -- display contents of an ELF format file
   2    Copyright (C) 1998-2017 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   assert (filedata->section_headers != NULL);
 659
 660   for (i = 0; i < filedata->file_header.e_shnum; i++)
 661     if (streq (SECTION_NAME (filedata->section_headers + i), name))
 662       return filedata->section_headers + i;
 663
 664   return NULL;
 665 }
 666
 667 /* Return a pointer to a section containing ADDR, or NULL if no such
 668    section exists.  */
 669
 670 static Elf_Internal_Shdr *
 671 find_section_by_address (Filedata * filedata, bfd_vma addr)
 672 {
 673   unsigned int i;
 674
 675   for (i = 0; i < filedata->file_header.e_shnum; i++)
 676     {
 677       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 678
 679       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 680         return sec;
 681     }
 682
 683   return NULL;
 684 }
 685
 686 static Elf_Internal_Shdr *
 687 find_section_by_type (Filedata * filedata, unsigned int type)
 688 {
 689   unsigned int i;
 690
 691   for (i = 0; i < filedata->file_header.e_shnum; i++)
 692     {
 693       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 694
 695       if (sec->sh_type == type)
 696         return sec;
 697     }
 698
 699   return NULL;
 700 }
 701
 702 /* Return a pointer to section NAME, or NULL if no such section exists,
 703    restricted to the list of sections given in SET.  */
 704
 705 static Elf_Internal_Shdr *
 706 find_section_in_set (Filedata * filedata, const char * name, unsigned int * set)
 707 {
 708   unsigned int i;
 709
 710   if (set != NULL)
 711     {
 712       while ((i = *set++) > 0)
 713         {
 714           /* See PR 21156 for a reproducer.  */
 715           if (i >= filedata->file_header.e_shnum)
 716             continue; /* FIXME: Should we issue an error message ?  */
 717
 718           if (streq (SECTION_NAME (filedata->section_headers + i), name))
 719             return filedata->section_headers + i;
 720         }
 721     }
 722
 723   return find_section (filedata, name);
 724 }
 725
 726 /* Read an unsigned LEB128 encoded value from DATA.
 727    Set *LENGTH_RETURN to the number of bytes read.  */
 728
 729 static inline unsigned long
 730 read_uleb128 (unsigned char * data,
 731               unsigned int * length_return,
 732               const unsigned char * const end)
 733 {
 734   return read_leb128 (data, length_return, FALSE, end);
 735 }
 736
 737 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
 738    This OS has so many departures from the ELF standard that we test it at
 739    many places.  */
 740
 741 static inline bfd_boolean
 742 is_ia64_vms (Filedata * filedata)
 743 {
 744   return filedata->file_header.e_machine == EM_IA_64
 745     && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 746 }
 747
 748 /* Guess the relocation size commonly used by the specific machines.  */
 749
 750 static bfd_boolean
 751 guess_is_rela (unsigned int e_machine)
 752 {
 753   switch (e_machine)
 754     {
 755       /* Targets that use REL relocations.  */
 756     case EM_386:
 757     case EM_IAMCU:
 758     case EM_960:
 759     case EM_ARM:
 760     case EM_D10V:
 761     case EM_CYGNUS_D10V:
 762     case EM_DLX:
 763     case EM_MIPS:
 764     case EM_MIPS_RS3_LE:
 765     case EM_CYGNUS_M32R:
 766     case EM_SCORE:
 767     case EM_XGATE:
 768       return FALSE;
 769
 770       /* Targets that use RELA relocations.  */
 771     case EM_68K:
 772     case EM_860:
 773     case EM_AARCH64:
 774     case EM_ADAPTEVA_EPIPHANY:
 775     case EM_ALPHA:
 776     case EM_ALTERA_NIOS2:
 777     case EM_ARC:
 778     case EM_ARC_COMPACT:
 779     case EM_ARC_COMPACT2:
 780     case EM_AVR:
 781     case EM_AVR_OLD:
 782     case EM_BLACKFIN:
 783     case EM_CR16:
 784     case EM_CRIS:
 785     case EM_CRX:
 786     case EM_D30V:
 787     case EM_CYGNUS_D30V:
 788     case EM_FR30:
 789     case EM_FT32:
 790     case EM_CYGNUS_FR30:
 791     case EM_CYGNUS_FRV:
 792     case EM_H8S:
 793     case EM_H8_300:
 794     case EM_H8_300H:
 795     case EM_IA_64:
 796     case EM_IP2K:
 797     case EM_IP2K_OLD:
 798     case EM_IQ2000:
 799     case EM_LATTICEMICO32:
 800     case EM_M32C_OLD:
 801     case EM_M32C:
 802     case EM_M32R:
 803     case EM_MCORE:
 804     case EM_CYGNUS_MEP:
 805     case EM_METAG:
 806     case EM_MMIX:
 807     case EM_MN10200:
 808     case EM_CYGNUS_MN10200:
 809     case EM_MN10300:
 810     case EM_CYGNUS_MN10300:
 811     case EM_MOXIE:
 812     case EM_MSP430:
 813     case EM_MSP430_OLD:
 814     case EM_MT:
 815     case EM_NDS32:
 816     case EM_NIOS32:
 817     case EM_OR1K:
 818     case EM_PPC64:
 819     case EM_PPC:
 820     case EM_TI_PRU:
 821     case EM_RISCV:
 822     case EM_RL78:
 823     case EM_RX:
 824     case EM_S390:
 825     case EM_S390_OLD:
 826     case EM_SH:
 827     case EM_SPARC:
 828     case EM_SPARC32PLUS:
 829     case EM_SPARCV9:
 830     case EM_SPU:
 831     case EM_TI_C6000:
 832     case EM_TILEGX:
 833     case EM_TILEPRO:
 834     case EM_V800:
 835     case EM_V850:
 836     case EM_CYGNUS_V850:
 837     case EM_VAX:
 838     case EM_VISIUM:
 839     case EM_X86_64:
 840     case EM_L1OM:
 841     case EM_K1OM:
 842     case EM_XSTORMY16:
 843     case EM_XTENSA:
 844     case EM_XTENSA_OLD:
 845     case EM_MICROBLAZE:
 846     case EM_MICROBLAZE_OLD:
 847     case EM_WEBASSEMBLY:
 848       return TRUE;
 849
 850     case EM_68HC05:
 851     case EM_68HC08:
 852     case EM_68HC11:
 853     case EM_68HC16:
 854     case EM_FX66:
 855     case EM_ME16:
 856     case EM_MMA:
 857     case EM_NCPU:
 858     case EM_NDR1:
 859     case EM_PCP:
 860     case EM_ST100:
 861     case EM_ST19:
 862     case EM_ST7:
 863     case EM_ST9PLUS:
 864     case EM_STARCORE:
 865     case EM_SVX:
 866     case EM_TINYJ:
 867     default:
 868       warn (_("Don't know about relocations on this machine architecture\n"));
 869       return FALSE;
 870     }
 871 }
 872
 873 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 874    Returns TRUE upon success, FALSE otherwise.  If successful then a
 875    pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
 876    and the number of relocs loaded is placed in *NRELASP.  It is the caller's
 877    responsibility to free the allocated buffer.  */
 878
 879 static bfd_boolean
 880 slurp_rela_relocs (Filedata *            filedata,
 881                    unsigned long         rel_offset,
 882                    unsigned long         rel_size,
 883                    Elf_Internal_Rela **  relasp,
 884                    unsigned long *       nrelasp)
 885 {
 886   Elf_Internal_Rela * relas;
 887   size_t nrelas;
 888   unsigned int i;
 889
 890   if (is_32bit_elf)
 891     {
 892       Elf32_External_Rela * erelas;
 893
 894       erelas = (Elf32_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 895                                                  rel_size, _("32-bit relocation data"));
 896       if (!erelas)
 897         return FALSE;
 898
 899       nrelas = rel_size / sizeof (Elf32_External_Rela);
 900
 901       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 902                                              sizeof (Elf_Internal_Rela));
 903
 904       if (relas == NULL)
 905         {
 906           free (erelas);
 907           error (_("out of memory parsing relocs\n"));
 908           return FALSE;
 909         }
 910
 911       for (i = 0; i < nrelas; i++)
 912         {
 913           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 914           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 915           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 916         }
 917
 918       free (erelas);
 919     }
 920   else
 921     {
 922       Elf64_External_Rela * erelas;
 923
 924       erelas = (Elf64_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 925                                                  rel_size, _("64-bit relocation data"));
 926       if (!erelas)
 927         return FALSE;
 928
 929       nrelas = rel_size / sizeof (Elf64_External_Rela);
 930
 931       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 932                                              sizeof (Elf_Internal_Rela));
 933
 934       if (relas == NULL)
 935         {
 936           free (erelas);
 937           error (_("out of memory parsing relocs\n"));
 938           return FALSE;
 939         }
 940
 941       for (i = 0; i < nrelas; i++)
 942         {
 943           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 944           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 945           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 946
 947           /* The #ifdef BFD64 below is to prevent a compile time
 948              warning.  We know that if we do not have a 64 bit data
 949              type that we will never execute this code anyway.  */
 950 #ifdef BFD64
 951           if (filedata->file_header.e_machine == EM_MIPS
 952               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
 953             {
 954               /* In little-endian objects, r_info isn't really a
 955                  64-bit little-endian value: it has a 32-bit
 956                  little-endian symbol index followed by four
 957                  individual byte fields.  Reorder INFO
 958                  accordingly.  */
 959               bfd_vma inf = relas[i].r_info;
 960               inf = (((inf & 0xffffffff) << 32)
 961                       | ((inf >> 56) & 0xff)
 962                       | ((inf >> 40) & 0xff00)
 963                       | ((inf >> 24) & 0xff0000)
 964                       | ((inf >> 8) & 0xff000000));
 965               relas[i].r_info = inf;
 966             }
 967 #endif /* BFD64 */
 968         }
 969
 970       free (erelas);
 971     }
 972
 973   *relasp = relas;
 974   *nrelasp = nrelas;
 975   return TRUE;
 976 }
 977
 978 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 979    Returns TRUE upon success, FALSE otherwise.  If successful then a
 980    pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
 981    and the number of relocs loaded is placed in *NRELSP.  It is the caller's
 982    responsibility to free the allocated buffer.  */
 983
 984 static bfd_boolean
 985 slurp_rel_relocs (Filedata *            filedata,
 986                   unsigned long         rel_offset,
 987                   unsigned long         rel_size,
 988                   Elf_Internal_Rela **  relsp,
 989                   unsigned long *       nrelsp)
 990 {
 991   Elf_Internal_Rela * rels;
 992   size_t nrels;
 993   unsigned int i;
 994
 995   if (is_32bit_elf)
 996     {
 997       Elf32_External_Rel * erels;
 998
 999       erels = (Elf32_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1000                                                rel_size, _("32-bit relocation data"));
1001       if (!erels)
1002         return FALSE;
1003
1004       nrels = rel_size / sizeof (Elf32_External_Rel);
1005
1006       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1007
1008       if (rels == NULL)
1009         {
1010           free (erels);
1011           error (_("out of memory parsing relocs\n"));
1012           return FALSE;
1013         }
1014
1015       for (i = 0; i < nrels; i++)
1016         {
1017           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1018           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1019           rels[i].r_addend = 0;
1020         }
1021
1022       free (erels);
1023     }
1024   else
1025     {
1026       Elf64_External_Rel * erels;
1027
1028       erels = (Elf64_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1029                                                rel_size, _("64-bit relocation data"));
1030       if (!erels)
1031         return FALSE;
1032
1033       nrels = rel_size / sizeof (Elf64_External_Rel);
1034
1035       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1036
1037       if (rels == NULL)
1038         {
1039           free (erels);
1040           error (_("out of memory parsing relocs\n"));
1041           return FALSE;
1042         }
1043
1044       for (i = 0; i < nrels; i++)
1045         {
1046           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1047           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1048           rels[i].r_addend = 0;
1049
1050           /* The #ifdef BFD64 below is to prevent a compile time
1051              warning.  We know that if we do not have a 64 bit data
1052              type that we will never execute this code anyway.  */
1053 #ifdef BFD64
1054           if (filedata->file_header.e_machine == EM_MIPS
1055               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
1056             {
1057               /* In little-endian objects, r_info isn't really a
1058                  64-bit little-endian value: it has a 32-bit
1059                  little-endian symbol index followed by four
1060                  individual byte fields.  Reorder INFO
1061                  accordingly.  */
1062               bfd_vma inf = rels[i].r_info;
1063               inf = (((inf & 0xffffffff) << 32)
1064                      | ((inf >> 56) & 0xff)
1065                      | ((inf >> 40) & 0xff00)
1066                      | ((inf >> 24) & 0xff0000)
1067                      | ((inf >> 8) & 0xff000000));
1068               rels[i].r_info = inf;
1069             }
1070 #endif /* BFD64 */
1071         }
1072
1073       free (erels);
1074     }
1075
1076   *relsp = rels;
1077   *nrelsp = nrels;
1078   return TRUE;
1079 }
1080
1081 /* Returns the reloc type extracted from the reloc info field.  */
1082
1083 static unsigned int
1084 get_reloc_type (Filedata * filedata, bfd_vma reloc_info)
1085 {
1086   if (is_32bit_elf)
1087     return ELF32_R_TYPE (reloc_info);
1088
1089   switch (filedata->file_header.e_machine)
1090     {
1091     case EM_MIPS:
1092       /* Note: We assume that reloc_info has already been adjusted for us.  */
1093       return ELF64_MIPS_R_TYPE (reloc_info);
1094
1095     case EM_SPARCV9:
1096       return ELF64_R_TYPE_ID (reloc_info);
1097
1098     default:
1099       return ELF64_R_TYPE (reloc_info);
1100     }
1101 }
1102
1103 /* Return the symbol index extracted from the reloc info field.  */
1104
1105 static bfd_vma
1106 get_reloc_symindex (bfd_vma reloc_info)
1107 {
1108   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1109 }
1110
1111 static inline bfd_boolean
1112 uses_msp430x_relocs (Filedata * filedata)
1113 {
1114   return
1115     filedata->file_header.e_machine == EM_MSP430 /* Paranoia.  */
1116     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
1117     && (((filedata->file_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1118         /* TI compiler uses ELFOSABI_NONE.  */
1119         || (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1120 }
1121
1122 /* Display the contents of the relocation data found at the specified
1123    offset.  */
1124
1125 static bfd_boolean
1126 dump_relocations (Filedata *          filedata,
1127                   unsigned long       rel_offset,
1128                   unsigned long       rel_size,
1129                   Elf_Internal_Sym *  symtab,
1130                   unsigned long       nsyms,
1131                   char *              strtab,
1132                   unsigned long       strtablen,
1133                   int                 is_rela,
1134                   bfd_boolean         is_dynsym)
1135 {
1136   unsigned long i;
1137   Elf_Internal_Rela * rels;
1138   bfd_boolean res = TRUE;
1139
1140   if (is_rela == UNKNOWN)
1141     is_rela = guess_is_rela (filedata->file_header.e_machine);
1142
1143   if (is_rela)
1144     {
1145       if (!slurp_rela_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1146         return FALSE;
1147     }
1148   else
1149     {
1150       if (!slurp_rel_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1151         return FALSE;
1152     }
1153
1154   if (is_32bit_elf)
1155     {
1156       if (is_rela)
1157         {
1158           if (do_wide)
1159             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
1160           else
1161             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
1162         }
1163       else
1164         {
1165           if (do_wide)
1166             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
1167           else
1168             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
1169         }
1170     }
1171   else
1172     {
1173       if (is_rela)
1174         {
1175           if (do_wide)
1176             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
1177           else
1178             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
1179         }
1180       else
1181         {
1182           if (do_wide)
1183             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
1184           else
1185             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
1186         }
1187     }
1188
1189   for (i = 0; i < rel_size; i++)
1190     {
1191       const char * rtype;
1192       bfd_vma offset;
1193       bfd_vma inf;
1194       bfd_vma symtab_index;
1195       bfd_vma type;
1196
1197       offset = rels[i].r_offset;
1198       inf    = rels[i].r_info;
1199
1200       type = get_reloc_type (filedata, inf);
1201       symtab_index = get_reloc_symindex  (inf);
1202
1203       if (is_32bit_elf)
1204         {
1205           printf ("%8.8lx  %8.8lx ",
1206                   (unsigned long) offset & 0xffffffff,
1207                   (unsigned long) inf & 0xffffffff);
1208         }
1209       else
1210         {
1211 #if BFD_HOST_64BIT_LONG
1212           printf (do_wide
1213                   ? "%16.16lx  %16.16lx "
1214                   : "%12.12lx  %12.12lx ",
1215                   offset, inf);
1216 #elif BFD_HOST_64BIT_LONG_LONG
1217 #ifndef __MSVCRT__
1218           printf (do_wide
1219                   ? "%16.16llx  %16.16llx "
1220                   : "%12.12llx  %12.12llx ",
1221                   offset, inf);
1222 #else
1223           printf (do_wide
1224                   ? "%16.16I64x  %16.16I64x "
1225                   : "%12.12I64x  %12.12I64x ",
1226                   offset, inf);
1227 #endif
1228 #else
1229           printf (do_wide
1230                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1231                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1232                   _bfd_int64_high (offset),
1233                   _bfd_int64_low (offset),
1234                   _bfd_int64_high (inf),
1235                   _bfd_int64_low (inf));
1236 #endif
1237         }
1238
1239       switch (filedata->file_header.e_machine)
1240         {
1241         default:
1242           rtype = NULL;
1243           break;
1244
1245         case EM_AARCH64:
1246           rtype = elf_aarch64_reloc_type (type);
1247           break;
1248
1249         case EM_M32R:
1250         case EM_CYGNUS_M32R:
1251           rtype = elf_m32r_reloc_type (type);
1252           break;
1253
1254         case EM_386:
1255         case EM_IAMCU:
1256           rtype = elf_i386_reloc_type (type);
1257           break;
1258
1259         case EM_68HC11:
1260         case EM_68HC12:
1261           rtype = elf_m68hc11_reloc_type (type);
1262           break;
1263
1264         case EM_68K:
1265           rtype = elf_m68k_reloc_type (type);
1266           break;
1267
1268         case EM_960:
1269           rtype = elf_i960_reloc_type (type);
1270           break;
1271
1272         case EM_AVR:
1273         case EM_AVR_OLD:
1274           rtype = elf_avr_reloc_type (type);
1275           break;
1276
1277         case EM_OLD_SPARCV9:
1278         case EM_SPARC32PLUS:
1279         case EM_SPARCV9:
1280         case EM_SPARC:
1281           rtype = elf_sparc_reloc_type (type);
1282           break;
1283
1284         case EM_SPU:
1285           rtype = elf_spu_reloc_type (type);
1286           break;
1287
1288         case EM_V800:
1289           rtype = v800_reloc_type (type);
1290           break;
1291         case EM_V850:
1292         case EM_CYGNUS_V850:
1293           rtype = v850_reloc_type (type);
1294           break;
1295
1296         case EM_D10V:
1297         case EM_CYGNUS_D10V:
1298           rtype = elf_d10v_reloc_type (type);
1299           break;
1300
1301         case EM_D30V:
1302         case EM_CYGNUS_D30V:
1303           rtype = elf_d30v_reloc_type (type);
1304           break;
1305
1306         case EM_DLX:
1307           rtype = elf_dlx_reloc_type (type);
1308           break;
1309
1310         case EM_SH:
1311           rtype = elf_sh_reloc_type (type);
1312           break;
1313
1314         case EM_MN10300:
1315         case EM_CYGNUS_MN10300:
1316           rtype = elf_mn10300_reloc_type (type);
1317           break;
1318
1319         case EM_MN10200:
1320         case EM_CYGNUS_MN10200:
1321           rtype = elf_mn10200_reloc_type (type);
1322           break;
1323
1324         case EM_FR30:
1325         case EM_CYGNUS_FR30:
1326           rtype = elf_fr30_reloc_type (type);
1327           break;
1328
1329         case EM_CYGNUS_FRV:
1330           rtype = elf_frv_reloc_type (type);
1331           break;
1332
1333         case EM_FT32:
1334           rtype = elf_ft32_reloc_type (type);
1335           break;
1336
1337         case EM_MCORE:
1338           rtype = elf_mcore_reloc_type (type);
1339           break;
1340
1341         case EM_MMIX:
1342           rtype = elf_mmix_reloc_type (type);
1343           break;
1344
1345         case EM_MOXIE:
1346           rtype = elf_moxie_reloc_type (type);
1347           break;
1348
1349         case EM_MSP430:
1350           if (uses_msp430x_relocs (filedata))
1351             {
1352               rtype = elf_msp430x_reloc_type (type);
1353               break;
1354             }
1355           /* Fall through.  */
1356         case EM_MSP430_OLD:
1357           rtype = elf_msp430_reloc_type (type);
1358           break;
1359
1360         case EM_NDS32:
1361           rtype = elf_nds32_reloc_type (type);
1362           break;
1363
1364         case EM_PPC:
1365           rtype = elf_ppc_reloc_type (type);
1366           break;
1367
1368         case EM_PPC64:
1369           rtype = elf_ppc64_reloc_type (type);
1370           break;
1371
1372         case EM_MIPS:
1373         case EM_MIPS_RS3_LE:
1374           rtype = elf_mips_reloc_type (type);
1375           break;
1376
1377         case EM_RISCV:
1378           rtype = elf_riscv_reloc_type (type);
1379           break;
1380
1381         case EM_ALPHA:
1382           rtype = elf_alpha_reloc_type (type);
1383           break;
1384
1385         case EM_ARM:
1386           rtype = elf_arm_reloc_type (type);
1387           break;
1388
1389         case EM_ARC:
1390         case EM_ARC_COMPACT:
1391         case EM_ARC_COMPACT2:
1392           rtype = elf_arc_reloc_type (type);
1393           break;
1394
1395         case EM_PARISC:
1396           rtype = elf_hppa_reloc_type (type);
1397           break;
1398
1399         case EM_H8_300:
1400         case EM_H8_300H:
1401         case EM_H8S:
1402           rtype = elf_h8_reloc_type (type);
1403           break;
1404
1405         case EM_OR1K:
1406           rtype = elf_or1k_reloc_type (type);
1407           break;
1408
1409         case EM_PJ:
1410         case EM_PJ_OLD:
1411           rtype = elf_pj_reloc_type (type);
1412           break;
1413         case EM_IA_64:
1414           rtype = elf_ia64_reloc_type (type);
1415           break;
1416
1417         case EM_CRIS:
1418           rtype = elf_cris_reloc_type (type);
1419           break;
1420
1421         case EM_860:
1422           rtype = elf_i860_reloc_type (type);
1423           break;
1424
1425         case EM_X86_64:
1426         case EM_L1OM:
1427         case EM_K1OM:
1428           rtype = elf_x86_64_reloc_type (type);
1429           break;
1430
1431         case EM_S370:
1432           rtype = i370_reloc_type (type);
1433           break;
1434
1435         case EM_S390_OLD:
1436         case EM_S390:
1437           rtype = elf_s390_reloc_type (type);
1438           break;
1439
1440         case EM_SCORE:
1441           rtype = elf_score_reloc_type (type);
1442           break;
1443
1444         case EM_XSTORMY16:
1445           rtype = elf_xstormy16_reloc_type (type);
1446           break;
1447
1448         case EM_CRX:
1449           rtype = elf_crx_reloc_type (type);
1450           break;
1451
1452         case EM_VAX:
1453           rtype = elf_vax_reloc_type (type);
1454           break;
1455
1456         case EM_VISIUM:
1457           rtype = elf_visium_reloc_type (type);
1458           break;
1459
1460         case EM_ADAPTEVA_EPIPHANY:
1461           rtype = elf_epiphany_reloc_type (type);
1462           break;
1463
1464         case EM_IP2K:
1465         case EM_IP2K_OLD:
1466           rtype = elf_ip2k_reloc_type (type);
1467           break;
1468
1469         case EM_IQ2000:
1470           rtype = elf_iq2000_reloc_type (type);
1471           break;
1472
1473         case EM_XTENSA_OLD:
1474         case EM_XTENSA:
1475           rtype = elf_xtensa_reloc_type (type);
1476           break;
1477
1478         case EM_LATTICEMICO32:
1479           rtype = elf_lm32_reloc_type (type);
1480           break;
1481
1482         case EM_M32C_OLD:
1483         case EM_M32C:
1484           rtype = elf_m32c_reloc_type (type);
1485           break;
1486
1487         case EM_MT:
1488           rtype = elf_mt_reloc_type (type);
1489           break;
1490
1491         case EM_BLACKFIN:
1492           rtype = elf_bfin_reloc_type (type);
1493           break;
1494
1495         case EM_CYGNUS_MEP:
1496           rtype = elf_mep_reloc_type (type);
1497           break;
1498
1499         case EM_CR16:
1500           rtype = elf_cr16_reloc_type (type);
1501           break;
1502
1503         case EM_MICROBLAZE:
1504         case EM_MICROBLAZE_OLD:
1505           rtype = elf_microblaze_reloc_type (type);
1506           break;
1507
1508         case EM_RL78:
1509           rtype = elf_rl78_reloc_type (type);
1510           break;
1511
1512         case EM_RX:
1513           rtype = elf_rx_reloc_type (type);
1514           break;
1515
1516         case EM_METAG:
1517           rtype = elf_metag_reloc_type (type);
1518           break;
1519
1520         case EM_XC16X:
1521         case EM_C166:
1522           rtype = elf_xc16x_reloc_type (type);
1523           break;
1524
1525         case EM_TI_C6000:
1526           rtype = elf_tic6x_reloc_type (type);
1527           break;
1528
1529         case EM_TILEGX:
1530           rtype = elf_tilegx_reloc_type (type);
1531           break;
1532
1533         case EM_TILEPRO:
1534           rtype = elf_tilepro_reloc_type (type);
1535           break;
1536
1537         case EM_WEBASSEMBLY:
1538           rtype = elf_wasm32_reloc_type (type);
1539           break;
1540
1541         case EM_XGATE:
1542           rtype = elf_xgate_reloc_type (type);
1543           break;
1544
1545         case EM_ALTERA_NIOS2:
1546           rtype = elf_nios2_reloc_type (type);
1547           break;
1548
1549         case EM_TI_PRU:
1550           rtype = elf_pru_reloc_type (type);
1551           break;
1552         }
1553
1554       if (rtype == NULL)
1555         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1556       else
1557         printf (do_wide ? "%-22s" : "%-17.17s", rtype);
1558
1559       if (filedata->file_header.e_machine == EM_ALPHA
1560           && rtype != NULL
1561           && streq (rtype, "R_ALPHA_LITUSE")
1562           && is_rela)
1563         {
1564           switch (rels[i].r_addend)
1565             {
1566             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1567             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1568             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1569             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1570             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1571             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1572             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1573             default: rtype = NULL;
1574             }
1575
1576           if (rtype)
1577             printf (" (%s)", rtype);
1578           else
1579             {
1580               putchar (' ');
1581               printf (_("<unknown addend: %lx>"),
1582                       (unsigned long) rels[i].r_addend);
1583               res = FALSE;
1584             }
1585         }
1586       else if (symtab_index)
1587         {
1588           if (symtab == NULL || symtab_index >= nsyms)
1589             {
1590               error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1591               res = FALSE;
1592             }
1593           else
1594             {
1595               Elf_Internal_Sym * psym;
1596               const char * version_string;
1597               enum versioned_symbol_info sym_info;
1598               unsigned short vna_other;
1599
1600               psym = symtab + symtab_index;
1601
1602               version_string
1603                 = get_symbol_version_string (filedata, is_dynsym,
1604                                              strtab, strtablen,
1605                                              symtab_index,
1606                                              psym,
1607                                              &sym_info,
1608                                              &vna_other);
1609
1610               printf (" ");
1611
1612               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1613                 {
1614                   const char * name;
1615                   unsigned int len;
1616                   unsigned int width = is_32bit_elf ? 8 : 14;
1617
1618                   /* Relocations against GNU_IFUNC symbols do not use the value
1619                      of the symbol as the address to relocate against.  Instead
1620                      they invoke the function named by the symbol and use its
1621                      result as the address for relocation.
1622
1623                      To indicate this to the user, do not display the value of
1624                      the symbol in the "Symbols's Value" field.  Instead show
1625                      its name followed by () as a hint that the symbol is
1626                      invoked.  */
1627
1628                   if (strtab == NULL
1629                       || psym->st_name == 0
1630                       || psym->st_name >= strtablen)
1631                     name = "??";
1632                   else
1633                     name = strtab + psym->st_name;
1634
1635                   len = print_symbol (width, name);
1636                   if (version_string)
1637                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1638                             version_string);
1639                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1640                 }
1641               else
1642                 {
1643                   print_vma (psym->st_value, LONG_HEX);
1644
1645                   printf (is_32bit_elf ? "   " : " ");
1646                 }
1647
1648               if (psym->st_name == 0)
1649                 {
1650                   const char * sec_name = "<null>";
1651                   char name_buf[40];
1652
1653                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1654                     {
1655                       if (psym->st_shndx < filedata->file_header.e_shnum)
1656                         sec_name = SECTION_NAME (filedata->section_headers + psym->st_shndx);
1657                       else if (psym->st_shndx == SHN_ABS)
1658                         sec_name = "ABS";
1659                       else if (psym->st_shndx == SHN_COMMON)
1660                         sec_name = "COMMON";
1661                       else if ((filedata->file_header.e_machine == EM_MIPS
1662                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1663                                || (filedata->file_header.e_machine == EM_TI_C6000
1664                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1665                         sec_name = "SCOMMON";
1666                       else if (filedata->file_header.e_machine == EM_MIPS
1667                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1668                         sec_name = "SUNDEF";
1669                       else if ((filedata->file_header.e_machine == EM_X86_64
1670                                 || filedata->file_header.e_machine == EM_L1OM
1671                                 || filedata->file_header.e_machine == EM_K1OM)
1672                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1673                         sec_name = "LARGE_COMMON";
1674                       else if (filedata->file_header.e_machine == EM_IA_64
1675                                && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1676                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1677                         sec_name = "ANSI_COM";
1678                       else if (is_ia64_vms (filedata)
1679                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1680                         sec_name = "VMS_SYMVEC";
1681                       else
1682                         {
1683                           sprintf (name_buf, "<section 0x%x>",
1684                                    (unsigned int) psym->st_shndx);
1685                           sec_name = name_buf;
1686                         }
1687                     }
1688                   print_symbol (22, sec_name);
1689                 }
1690               else if (strtab == NULL)
1691                 printf (_("<string table index: %3ld>"), psym->st_name);
1692               else if (psym->st_name >= strtablen)
1693                 {
1694                   error (_("<corrupt string table index: %3ld>"), psym->st_name);
1695                   res = FALSE;
1696                 }
1697               else
1698                 {
1699                   print_symbol (22, strtab + psym->st_name);
1700                   if (version_string)
1701                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1702                             version_string);
1703                 }
1704
1705               if (is_rela)
1706                 {
1707                   bfd_vma off = rels[i].r_addend;
1708
1709                   if ((bfd_signed_vma) off < 0)
1710                     printf (" - %" BFD_VMA_FMT "x", - off);
1711                   else
1712                     printf (" + %" BFD_VMA_FMT "x", off);
1713                 }
1714             }
1715         }
1716       else if (is_rela)
1717         {
1718           bfd_vma off = rels[i].r_addend;
1719
1720           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1721           if ((bfd_signed_vma) off < 0)
1722             printf ("-%" BFD_VMA_FMT "x", - off);
1723           else
1724             printf ("%" BFD_VMA_FMT "x", off);
1725         }
1726
1727       if (filedata->file_header.e_machine == EM_SPARCV9
1728           && rtype != NULL
1729           && streq (rtype, "R_SPARC_OLO10"))
1730         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1731
1732       putchar ('\n');
1733
1734 #ifdef BFD64
1735       if (! is_32bit_elf && filedata->file_header.e_machine == EM_MIPS)
1736         {
1737           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1738           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1739           const char * rtype2 = elf_mips_reloc_type (type2);
1740           const char * rtype3 = elf_mips_reloc_type (type3);
1741
1742           printf ("                    Type2: ");
1743
1744           if (rtype2 == NULL)
1745             printf (_("unrecognized: %-7lx"),
1746                     (unsigned long) type2 & 0xffffffff);
1747           else
1748             printf ("%-17.17s", rtype2);
1749
1750           printf ("\n                    Type3: ");
1751
1752           if (rtype3 == NULL)
1753             printf (_("unrecognized: %-7lx"),
1754                     (unsigned long) type3 & 0xffffffff);
1755           else
1756             printf ("%-17.17s", rtype3);
1757
1758           putchar ('\n');
1759         }
1760 #endif /* BFD64 */
1761     }
1762
1763   free (rels);
1764
1765   return res;
1766 }
1767
1768 static const char *
1769 get_mips_dynamic_type (unsigned long type)
1770 {
1771   switch (type)
1772     {
1773     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1774     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1775     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1776     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1777     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1778     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1779     case DT_MIPS_MSYM: return "MIPS_MSYM";
1780     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1781     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1782     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1783     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1784     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1785     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1786     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1787     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1788     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1789     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1790     case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1791     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1792     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1793     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1794     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1795     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1796     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1797     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1798     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1799     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1800     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1801     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1802     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1803     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1804     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1805     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1806     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1807     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1808     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1809     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1810     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1811     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1812     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1813     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1814     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1815     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1816     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1817     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1818     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1819     default:
1820       return NULL;
1821     }
1822 }
1823
1824 static const char *
1825 get_sparc64_dynamic_type (unsigned long type)
1826 {
1827   switch (type)
1828     {
1829     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1830     default:
1831       return NULL;
1832     }
1833 }
1834
1835 static const char *
1836 get_ppc_dynamic_type (unsigned long type)
1837 {
1838   switch (type)
1839     {
1840     case DT_PPC_GOT:    return "PPC_GOT";
1841     case DT_PPC_OPT:    return "PPC_OPT";
1842     default:
1843       return NULL;
1844     }
1845 }
1846
1847 static const char *
1848 get_ppc64_dynamic_type (unsigned long type)
1849 {
1850   switch (type)
1851     {
1852     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1853     case DT_PPC64_OPD:    return "PPC64_OPD";
1854     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1855     case DT_PPC64_OPT:    return "PPC64_OPT";
1856     default:
1857       return NULL;
1858     }
1859 }
1860
1861 static const char *
1862 get_parisc_dynamic_type (unsigned long type)
1863 {
1864   switch (type)
1865     {
1866     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1867     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1868     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1869     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1870     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1871     case DT_HP_PREINIT:         return "HP_PREINIT";
1872     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1873     case DT_HP_NEEDED:          return "HP_NEEDED";
1874     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1875     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1876     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1877     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1878     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1879     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1880     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1881     case DT_HP_FILTERED:        return "HP_FILTERED";
1882     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1883     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1884     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1885     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1886     case DT_PLT:                return "PLT";
1887     case DT_PLT_SIZE:           return "PLT_SIZE";
1888     case DT_DLT:                return "DLT";
1889     case DT_DLT_SIZE:           return "DLT_SIZE";
1890     default:
1891       return NULL;
1892     }
1893 }
1894
1895 static const char *
1896 get_ia64_dynamic_type (unsigned long type)
1897 {
1898   switch (type)
1899     {
1900     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1901     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1902     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1903     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1904     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1905     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1906     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1907     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1908     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1909     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1910     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1911     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1912     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1913     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1914     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1915     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1916     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1917     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1918     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1919     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1920     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1921     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1922     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1923     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1924     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1925     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1926     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1927     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1928     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1929     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1930     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1931     default:
1932       return NULL;
1933     }
1934 }
1935
1936 static const char *
1937 get_solaris_section_type (unsigned long type)
1938 {
1939   switch (type)
1940     {
1941     case 0x6fffffee: return "SUNW_ancillary";
1942     case 0x6fffffef: return "SUNW_capchain";
1943     case 0x6ffffff0: return "SUNW_capinfo";
1944     case 0x6ffffff1: return "SUNW_symsort";
1945     case 0x6ffffff2: return "SUNW_tlssort";
1946     case 0x6ffffff3: return "SUNW_LDYNSYM";
1947     case 0x6ffffff4: return "SUNW_dof";
1948     case 0x6ffffff5: return "SUNW_cap";
1949     case 0x6ffffff6: return "SUNW_SIGNATURE";
1950     case 0x6ffffff7: return "SUNW_ANNOTATE";
1951     case 0x6ffffff8: return "SUNW_DEBUGSTR";
1952     case 0x6ffffff9: return "SUNW_DEBUG";
1953     case 0x6ffffffa: return "SUNW_move";
1954     case 0x6ffffffb: return "SUNW_COMDAT";
1955     case 0x6ffffffc: return "SUNW_syminfo";
1956     case 0x6ffffffd: return "SUNW_verdef";
1957     case 0x6ffffffe: return "SUNW_verneed";
1958     case 0x6fffffff: return "SUNW_versym";
1959     case 0x70000000: return "SPARC_GOTDATA";
1960     default: return NULL;
1961     }
1962 }
1963
1964 static const char *
1965 get_alpha_dynamic_type (unsigned long type)
1966 {
1967   switch (type)
1968     {
1969     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1970     default: return NULL;
1971     }
1972 }
1973
1974 static const char *
1975 get_score_dynamic_type (unsigned long type)
1976 {
1977   switch (type)
1978     {
1979     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1980     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
1981     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
1982     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
1983     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
1984     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
1985     default:                    return NULL;
1986     }
1987 }
1988
1989 static const char *
1990 get_tic6x_dynamic_type (unsigned long type)
1991 {
1992   switch (type)
1993     {
1994     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1995     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1996     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
1997     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
1998     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
1999     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
2000     default:                   return NULL;
2001     }
2002 }
2003
2004 static const char *
2005 get_nios2_dynamic_type (unsigned long type)
2006 {
2007   switch (type)
2008     {
2009     case DT_NIOS2_GP: return "NIOS2_GP";
2010     default:          return NULL;
2011     }
2012 }
2013
2014 static const char *
2015 get_solaris_dynamic_type (unsigned long type)
2016 {
2017   switch (type)
2018     {
2019     case 0x6000000d: return "SUNW_AUXILIARY";
2020     case 0x6000000e: return "SUNW_RTLDINF";
2021     case 0x6000000f: return "SUNW_FILTER";
2022     case 0x60000010: return "SUNW_CAP";
2023     case 0x60000011: return "SUNW_SYMTAB";
2024     case 0x60000012: return "SUNW_SYMSZ";
2025     case 0x60000013: return "SUNW_SORTENT";
2026     case 0x60000014: return "SUNW_SYMSORT";
2027     case 0x60000015: return "SUNW_SYMSORTSZ";
2028     case 0x60000016: return "SUNW_TLSSORT";
2029     case 0x60000017: return "SUNW_TLSSORTSZ";
2030     case 0x60000018: return "SUNW_CAPINFO";
2031     case 0x60000019: return "SUNW_STRPAD";
2032     case 0x6000001a: return "SUNW_CAPCHAIN";
2033     case 0x6000001b: return "SUNW_LDMACH";
2034     case 0x6000001d: return "SUNW_CAPCHAINENT";
2035     case 0x6000001f: return "SUNW_CAPCHAINSZ";
2036     case 0x60000021: return "SUNW_PARENT";
2037     case 0x60000023: return "SUNW_ASLR";
2038     case 0x60000025: return "SUNW_RELAX";
2039     case 0x60000029: return "SUNW_NXHEAP";
2040     case 0x6000002b: return "SUNW_NXSTACK";
2041
2042     case 0x70000001: return "SPARC_REGISTER";
2043     case 0x7ffffffd: return "AUXILIARY";
2044     case 0x7ffffffe: return "USED";
2045     case 0x7fffffff: return "FILTER";
2046
2047     default: return NULL;
2048     }
2049 }
2050
2051 static const char *
2052 get_dynamic_type (Filedata * filedata, unsigned long type)
2053 {
2054   static char buff[64];
2055
2056   switch (type)
2057     {
2058     case DT_NULL:       return "NULL";
2059     case DT_NEEDED:     return "NEEDED";
2060     case DT_PLTRELSZ:   return "PLTRELSZ";
2061     case DT_PLTGOT:     return "PLTGOT";
2062     case DT_HASH:       return "HASH";
2063     case DT_STRTAB:     return "STRTAB";
2064     case DT_SYMTAB:     return "SYMTAB";
2065     case DT_RELA:       return "RELA";
2066     case DT_RELASZ:     return "RELASZ";
2067     case DT_RELAENT:    return "RELAENT";
2068     case DT_STRSZ:      return "STRSZ";
2069     case DT_SYMENT:     return "SYMENT";
2070     case DT_INIT:       return "INIT";
2071     case DT_FINI:       return "FINI";
2072     case DT_SONAME:     return "SONAME";
2073     case DT_RPATH:      return "RPATH";
2074     case DT_SYMBOLIC:   return "SYMBOLIC";
2075     case DT_REL:        return "REL";
2076     case DT_RELSZ:      return "RELSZ";
2077     case DT_RELENT:     return "RELENT";
2078     case DT_PLTREL:     return "PLTREL";
2079     case DT_DEBUG:      return "DEBUG";
2080     case DT_TEXTREL:    return "TEXTREL";
2081     case DT_JMPREL:     return "JMPREL";
2082     case DT_BIND_NOW:   return "BIND_NOW";
2083     case DT_INIT_ARRAY: return "INIT_ARRAY";
2084     case DT_FINI_ARRAY: return "FINI_ARRAY";
2085     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2086     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2087     case DT_RUNPATH:    return "RUNPATH";
2088     case DT_FLAGS:      return "FLAGS";
2089
2090     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2091     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2092     case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2093
2094     case DT_CHECKSUM:   return "CHECKSUM";
2095     case DT_PLTPADSZ:   return "PLTPADSZ";
2096     case DT_MOVEENT:    return "MOVEENT";
2097     case DT_MOVESZ:     return "MOVESZ";
2098     case DT_FEATURE:    return "FEATURE";
2099     case DT_POSFLAG_1:  return "POSFLAG_1";
2100     case DT_SYMINSZ:    return "SYMINSZ";
2101     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
2102
2103     case DT_ADDRRNGLO:  return "ADDRRNGLO";
2104     case DT_CONFIG:     return "CONFIG";
2105     case DT_DEPAUDIT:   return "DEPAUDIT";
2106     case DT_AUDIT:      return "AUDIT";
2107     case DT_PLTPAD:     return "PLTPAD";
2108     case DT_MOVETAB:    return "MOVETAB";
2109     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
2110
2111     case DT_VERSYM:     return "VERSYM";
2112
2113     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2114     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2115     case DT_RELACOUNT:  return "RELACOUNT";
2116     case DT_RELCOUNT:   return "RELCOUNT";
2117     case DT_FLAGS_1:    return "FLAGS_1";
2118     case DT_VERDEF:     return "VERDEF";
2119     case DT_VERDEFNUM:  return "VERDEFNUM";
2120     case DT_VERNEED:    return "VERNEED";
2121     case DT_VERNEEDNUM: return "VERNEEDNUM";
2122
2123     case DT_AUXILIARY:  return "AUXILIARY";
2124     case DT_USED:       return "USED";
2125     case DT_FILTER:     return "FILTER";
2126
2127     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2128     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2129     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2130     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2131     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2132     case DT_GNU_HASH:   return "GNU_HASH";
2133
2134     default:
2135       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2136         {
2137           const char * result;
2138
2139           switch (filedata->file_header.e_machine)
2140             {
2141             case EM_MIPS:
2142             case EM_MIPS_RS3_LE:
2143               result = get_mips_dynamic_type (type);
2144               break;
2145             case EM_SPARCV9:
2146               result = get_sparc64_dynamic_type (type);
2147               break;
2148             case EM_PPC:
2149               result = get_ppc_dynamic_type (type);
2150               break;
2151             case EM_PPC64:
2152               result = get_ppc64_dynamic_type (type);
2153               break;
2154             case EM_IA_64:
2155               result = get_ia64_dynamic_type (type);
2156               break;
2157             case EM_ALPHA:
2158               result = get_alpha_dynamic_type (type);
2159               break;
2160             case EM_SCORE:
2161               result = get_score_dynamic_type (type);
2162               break;
2163             case EM_TI_C6000:
2164               result = get_tic6x_dynamic_type (type);
2165               break;
2166             case EM_ALTERA_NIOS2:
2167               result = get_nios2_dynamic_type (type);
2168               break;
2169             default:
2170               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2171                 result = get_solaris_dynamic_type (type);
2172               else
2173                 result = NULL;
2174               break;
2175             }
2176
2177           if (result != NULL)
2178             return result;
2179
2180           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2181         }
2182       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2183                || (filedata->file_header.e_machine == EM_PARISC
2184                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2185         {
2186           const char * result;
2187
2188           switch (filedata->file_header.e_machine)
2189             {
2190             case EM_PARISC:
2191               result = get_parisc_dynamic_type (type);
2192               break;
2193             case EM_IA_64:
2194               result = get_ia64_dynamic_type (type);
2195               break;
2196             default:
2197               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2198                 result = get_solaris_dynamic_type (type);
2199               else
2200                 result = NULL;
2201               break;
2202             }
2203
2204           if (result != NULL)
2205             return result;
2206
2207           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2208                     type);
2209         }
2210       else
2211         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2212
2213       return buff;
2214     }
2215 }
2216
2217 static char *
2218 get_file_type (unsigned e_type)
2219 {
2220   static char buff[32];
2221
2222   switch (e_type)
2223     {
2224     case ET_NONE: return _("NONE (None)");
2225     case ET_REL:  return _("REL (Relocatable file)");
2226     case ET_EXEC: return _("EXEC (Executable file)");
2227     case ET_DYN:  return _("DYN (Shared object file)");
2228     case ET_CORE: return _("CORE (Core file)");
2229
2230     default:
2231       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2232         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2233       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2234         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2235       else
2236         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2237       return buff;
2238     }
2239 }
2240
2241 static char *
2242 get_machine_name (unsigned e_machine)
2243 {
2244   static char buff[64]; /* XXX */
2245
2246   switch (e_machine)
2247     {
2248       /* Please keep this switch table sorted by increasing EM_ value.  */
2249       /* 0 */
2250     case EM_NONE:               return _("None");
2251     case EM_M32:                return "WE32100";
2252     case EM_SPARC:              return "Sparc";
2253     case EM_386:                return "Intel 80386";
2254     case EM_68K:                return "MC68000";
2255     case EM_88K:                return "MC88000";
2256     case EM_IAMCU:              return "Intel MCU";
2257     case EM_860:                return "Intel 80860";
2258     case EM_MIPS:               return "MIPS R3000";
2259     case EM_S370:               return "IBM System/370";
2260       /* 10 */
2261     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
2262     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
2263     case EM_PARISC:             return "HPPA";
2264     case EM_VPP550:             return "Fujitsu VPP500";
2265     case EM_SPARC32PLUS:        return "Sparc v8+" ;
2266     case EM_960:                return "Intel 90860";
2267     case EM_PPC:                return "PowerPC";
2268       /* 20 */
2269     case EM_PPC64:              return "PowerPC64";
2270     case EM_S390_OLD:
2271     case EM_S390:               return "IBM S/390";
2272     case EM_SPU:                return "SPU";
2273       /* 30 */
2274     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
2275     case EM_FR20:               return "Fujitsu FR20";
2276     case EM_RH32:               return "TRW RH32";
2277     case EM_MCORE:              return "MCORE";
2278       /* 40 */
2279     case EM_ARM:                return "ARM";
2280     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
2281     case EM_SH:                 return "Renesas / SuperH SH";
2282     case EM_SPARCV9:            return "Sparc v9";
2283     case EM_TRICORE:            return "Siemens Tricore";
2284     case EM_ARC:                return "ARC";
2285     case EM_H8_300:             return "Renesas H8/300";
2286     case EM_H8_300H:            return "Renesas H8/300H";
2287     case EM_H8S:                return "Renesas H8S";
2288     case EM_H8_500:             return "Renesas H8/500";
2289       /* 50 */
2290     case EM_IA_64:              return "Intel IA-64";
2291     case EM_MIPS_X:             return "Stanford MIPS-X";
2292     case EM_COLDFIRE:           return "Motorola Coldfire";
2293     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
2294     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
2295     case EM_PCP:                return "Siemens PCP";
2296     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
2297     case EM_NDR1:               return "Denso NDR1 microprocesspr";
2298     case EM_STARCORE:           return "Motorola Star*Core processor";
2299     case EM_ME16:               return "Toyota ME16 processor";
2300       /* 60 */
2301     case EM_ST100:              return "STMicroelectronics ST100 processor";
2302     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
2303     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2304     case EM_PDSP:               return "Sony DSP processor";
2305     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
2306     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
2307     case EM_FX66:               return "Siemens FX66 microcontroller";
2308     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2309     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
2310     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
2311       /* 70 */
2312     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
2313     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
2314     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
2315     case EM_SVX:                return "Silicon Graphics SVx";
2316     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
2317     case EM_VAX:                return "Digital VAX";
2318     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
2319     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
2320     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2321     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2322       /* 80 */
2323     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2324     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2325     case EM_PRISM:              return "Vitesse Prism";
2326     case EM_AVR_OLD:
2327     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
2328     case EM_CYGNUS_FR30:
2329     case EM_FR30:               return "Fujitsu FR30";
2330     case EM_CYGNUS_D10V:
2331     case EM_D10V:               return "d10v";
2332     case EM_CYGNUS_D30V:
2333     case EM_D30V:               return "d30v";
2334     case EM_CYGNUS_V850:
2335     case EM_V850:               return "Renesas V850";
2336     case EM_CYGNUS_M32R:
2337     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
2338     case EM_CYGNUS_MN10300:
2339     case EM_MN10300:            return "mn10300";
2340       /* 90 */
2341     case EM_CYGNUS_MN10200:
2342     case EM_MN10200:            return "mn10200";
2343     case EM_PJ:                 return "picoJava";
2344     case EM_OR1K:               return "OpenRISC 1000";
2345     case EM_ARC_COMPACT:        return "ARCompact";
2346     case EM_XTENSA_OLD:
2347     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2348     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2349     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2350     case EM_NS32K:              return "National Semiconductor 32000 series";
2351     case EM_TPC:                return "Tenor Network TPC processor";
2352     case EM_SNP1K:              return "Trebia SNP 1000 processor";
2353       /* 100 */
2354     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2355     case EM_IP2K_OLD:
2356     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2357     case EM_MAX:                return "MAX Processor";
2358     case EM_CR:                 return "National Semiconductor CompactRISC";
2359     case EM_F2MC16:             return "Fujitsu F2MC16";
2360     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2361     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2362     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2363     case EM_SEP:                return "Sharp embedded microprocessor";
2364     case EM_ARCA:               return "Arca RISC microprocessor";
2365       /* 110 */
2366     case EM_UNICORE:            return "Unicore";
2367     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2368     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2369     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2370     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2371     case EM_XGATE:              return "Motorola XGATE embedded processor";
2372     case EM_C166:
2373     case EM_XC16X:              return "Infineon Technologies xc16x";
2374     case EM_M16C:               return "Renesas M16C series microprocessors";
2375     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2376     case EM_CE:                 return "Freescale Communication Engine RISC core";
2377       /* 120 */
2378     case EM_M32C:               return "Renesas M32c";
2379       /* 130 */
2380     case EM_TSK3000:            return "Altium TSK3000 core";
2381     case EM_RS08:               return "Freescale RS08 embedded processor";
2382     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2383     case EM_SCORE:              return "SUNPLUS S+Core";
2384     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2385     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2386     case EM_LATTICEMICO32:      return "Lattice Mico32";
2387     case EM_SE_C17:             return "Seiko Epson C17 family";
2388       /* 140 */
2389     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2390     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2391     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2392     case EM_TI_PRU:             return "TI PRU I/O processor";
2393       /* 160 */
2394     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2395     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2396     case EM_R32C:               return "Renesas R32C series microprocessors";
2397     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2398     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2399     case EM_8051:               return "Intel 8051 and variants";
2400     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2401     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2402     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2403     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2404       /* 170 */
2405     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2406     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2407     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2408     case EM_RX:                 return "Renesas RX";
2409     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2410     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2411     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2412     case EM_CR16:
2413     case EM_MICROBLAZE:
2414     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2415     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2416     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2417       /* 180 */
2418     case EM_L1OM:               return "Intel L1OM";
2419     case EM_K1OM:               return "Intel K1OM";
2420     case EM_INTEL182:           return "Intel (reserved)";
2421     case EM_AARCH64:            return "AArch64";
2422     case EM_ARM184:             return "ARM (reserved)";
2423     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor";
2424     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2425     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2426     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2427       /* 190 */
2428     case EM_CUDA:               return "NVIDIA CUDA architecture";
2429     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2430     case EM_CLOUDSHIELD:        return "CloudShield architecture family";
2431     case EM_COREA_1ST:          return "KIPO-KAIST Core-A 1st generation processor family";
2432     case EM_COREA_2ND:          return "KIPO-KAIST Core-A 2nd generation processor family";
2433     case EM_ARC_COMPACT2:       return "ARCv2";
2434     case EM_OPEN8:              return "Open8 8-bit RISC soft processor core";
2435     case EM_RL78:               return "Renesas RL78";
2436     case EM_VIDEOCORE5:         return "Broadcom VideoCore V processor";
2437     case EM_78K0R:              return "Renesas 78K0R";
2438       /* 200 */
2439     case EM_56800EX:            return "Freescale 56800EX Digital Signal Controller (DSC)";
2440     case EM_BA1:                return "Beyond BA1 CPU architecture";
2441     case EM_BA2:                return "Beyond BA2 CPU architecture";
2442     case EM_XCORE:              return "XMOS xCORE processor family";
2443     case EM_MCHP_PIC:           return "Microchip 8-bit PIC(r) family";
2444       /* 210 */
2445     case EM_KM32:               return "KM211 KM32 32-bit processor";
2446     case EM_KMX32:              return "KM211 KMX32 32-bit processor";
2447     case EM_KMX16:              return "KM211 KMX16 16-bit processor";
2448     case EM_KMX8:               return "KM211 KMX8 8-bit processor";
2449     case EM_KVARC:              return "KM211 KVARC processor";
2450     case EM_CDP:                return "Paneve CDP architecture family";
2451     case EM_COGE:               return "Cognitive Smart Memory Processor";
2452     case EM_COOL:               return "Bluechip Systems CoolEngine";
2453     case EM_NORC:               return "Nanoradio Optimized RISC";
2454     case EM_CSR_KALIMBA:        return "CSR Kalimba architecture family";
2455       /* 220 */
2456     case EM_Z80:                return "Zilog Z80";
2457     case EM_VISIUM:             return "CDS VISIUMcore processor";
2458     case EM_FT32:               return "FTDI Chip FT32";
2459     case EM_MOXIE:              return "Moxie";
2460     case EM_AMDGPU:             return "AMD GPU";
2461     case EM_RISCV:              return "RISC-V";
2462     case EM_LANAI:              return "Lanai 32-bit processor";
2463     case EM_BPF:                return "Linux BPF";
2464
2465       /* Large numbers...  */
2466     case EM_MT:                 return "Morpho Techologies MT processor";
2467     case EM_ALPHA:              return "Alpha";
2468     case EM_WEBASSEMBLY:        return "Web Assembly";
2469     case EM_DLX:                return "OpenDLX";
2470     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2471     case EM_IQ2000:             return "Vitesse IQ2000";
2472     case EM_M32C_OLD:
2473     case EM_NIOS32:             return "Altera Nios";
2474     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2475     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2476     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
2477
2478     default:
2479       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2480       return buff;
2481     }
2482 }
2483
2484 static void
2485 decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2486 {
2487   /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2.  Some
2488      other compilers don't a specific architecture type in the e_flags, and
2489      instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2490      architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2491      architectures.
2492
2493      Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2494      but also sets a specific architecture type in the e_flags field.
2495
2496      However, when decoding the flags we don't worry if we see an
2497      unexpected pairing, for example EM_ARC_COMPACT machine type, with
2498      ARCEM architecture type.  */
2499
2500   switch (e_flags & EF_ARC_MACH_MSK)
2501     {
2502       /* We only expect these to occur for EM_ARC_COMPACT2.  */
2503     case EF_ARC_CPU_ARCV2EM:
2504       strcat (buf, ", ARC EM");
2505       break;
2506     case EF_ARC_CPU_ARCV2HS:
2507       strcat (buf, ", ARC HS");
2508       break;
2509
2510       /* We only expect these to occur for EM_ARC_COMPACT.  */
2511     case E_ARC_MACH_ARC600:
2512       strcat (buf, ", ARC600");
2513       break;
2514     case E_ARC_MACH_ARC601:
2515       strcat (buf, ", ARC601");
2516       break;
2517     case E_ARC_MACH_ARC700:
2518       strcat (buf, ", ARC700");
2519       break;
2520
2521       /* The only times we should end up here are (a) A corrupt ELF, (b) A
2522          new ELF with new architecture being read by an old version of
2523          readelf, or (c) An ELF built with non-GNU compiler that does not
2524          set the architecture in the e_flags.  */
2525     default:
2526       if (e_machine == EM_ARC_COMPACT)
2527         strcat (buf, ", Unknown ARCompact");
2528       else
2529         strcat (buf, ", Unknown ARC");
2530       break;
2531     }
2532
2533   switch (e_flags & EF_ARC_OSABI_MSK)
2534     {
2535     case E_ARC_OSABI_ORIG:
2536       strcat (buf, ", (ABI:legacy)");
2537       break;
2538     case E_ARC_OSABI_V2:
2539       strcat (buf, ", (ABI:v2)");
2540       break;
2541       /* Only upstream 3.9+ kernels will support ARCv2 ISA.  */
2542     case E_ARC_OSABI_V3:
2543       strcat (buf, ", v3 no-legacy-syscalls ABI");
2544       break;
2545     case E_ARC_OSABI_V4:
2546       strcat (buf, ", v4 ABI");
2547       break;
2548     default:
2549       strcat (buf, ", unrecognised ARC OSABI flag");
2550       break;
2551     }
2552 }
2553
2554 static void
2555 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2556 {
2557   unsigned eabi;
2558   bfd_boolean unknown = FALSE;
2559
2560   eabi = EF_ARM_EABI_VERSION (e_flags);
2561   e_flags &= ~ EF_ARM_EABIMASK;
2562
2563   /* Handle "generic" ARM flags.  */
2564   if (e_flags & EF_ARM_RELEXEC)
2565     {
2566       strcat (buf, ", relocatable executable");
2567       e_flags &= ~ EF_ARM_RELEXEC;
2568     }
2569
2570   /* Now handle EABI specific flags.  */
2571   switch (eabi)
2572     {
2573     default:
2574       strcat (buf, ", <unrecognized EABI>");
2575       if (e_flags)
2576         unknown = TRUE;
2577       break;
2578
2579     case EF_ARM_EABI_VER1:
2580       strcat (buf, ", Version1 EABI");
2581       while (e_flags)
2582         {
2583           unsigned flag;
2584
2585           /* Process flags one bit at a time.  */
2586           flag = e_flags & - e_flags;
2587           e_flags &= ~ flag;
2588
2589           switch (flag)
2590             {
2591             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2592               strcat (buf, ", sorted symbol tables");
2593               break;
2594
2595             default:
2596               unknown = TRUE;
2597               break;
2598             }
2599         }
2600       break;
2601
2602     case EF_ARM_EABI_VER2:
2603       strcat (buf, ", Version2 EABI");
2604       while (e_flags)
2605         {
2606           unsigned flag;
2607
2608           /* Process flags one bit at a time.  */
2609           flag = e_flags & - e_flags;
2610           e_flags &= ~ flag;
2611
2612           switch (flag)
2613             {
2614             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2615               strcat (buf, ", sorted symbol tables");
2616               break;
2617
2618             case EF_ARM_DYNSYMSUSESEGIDX:
2619               strcat (buf, ", dynamic symbols use segment index");
2620               break;
2621
2622             case EF_ARM_MAPSYMSFIRST:
2623               strcat (buf, ", mapping symbols precede others");
2624               break;
2625
2626             default:
2627               unknown = TRUE;
2628               break;
2629             }
2630         }
2631       break;
2632
2633     case EF_ARM_EABI_VER3:
2634       strcat (buf, ", Version3 EABI");
2635       break;
2636
2637     case EF_ARM_EABI_VER4:
2638       strcat (buf, ", Version4 EABI");
2639       while (e_flags)
2640         {
2641           unsigned flag;
2642
2643           /* Process flags one bit at a time.  */
2644           flag = e_flags & - e_flags;
2645           e_flags &= ~ flag;
2646
2647           switch (flag)
2648             {
2649             case EF_ARM_BE8:
2650               strcat (buf, ", BE8");
2651               break;
2652
2653             case EF_ARM_LE8:
2654               strcat (buf, ", LE8");
2655               break;
2656
2657             default:
2658               unknown = TRUE;
2659               break;
2660             }
2661         }
2662       break;
2663
2664     case EF_ARM_EABI_VER5:
2665       strcat (buf, ", Version5 EABI");
2666       while (e_flags)
2667         {
2668           unsigned flag;
2669
2670           /* Process flags one bit at a time.  */
2671           flag = e_flags & - e_flags;
2672           e_flags &= ~ flag;
2673
2674           switch (flag)
2675             {
2676             case EF_ARM_BE8:
2677               strcat (buf, ", BE8");
2678               break;
2679
2680             case EF_ARM_LE8:
2681               strcat (buf, ", LE8");
2682               break;
2683
2684             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2685               strcat (buf, ", soft-float ABI");
2686               break;
2687
2688             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2689               strcat (buf, ", hard-float ABI");
2690               break;
2691
2692             default:
2693               unknown = TRUE;
2694               break;
2695             }
2696         }
2697       break;
2698
2699     case EF_ARM_EABI_UNKNOWN:
2700       strcat (buf, ", GNU EABI");
2701       while (e_flags)
2702         {
2703           unsigned flag;
2704
2705           /* Process flags one bit at a time.  */
2706           flag = e_flags & - e_flags;
2707           e_flags &= ~ flag;
2708
2709           switch (flag)
2710             {
2711             case EF_ARM_INTERWORK:
2712               strcat (buf, ", interworking enabled");
2713               break;
2714
2715             case EF_ARM_APCS_26:
2716               strcat (buf, ", uses APCS/26");
2717               break;
2718
2719             case EF_ARM_APCS_FLOAT:
2720               strcat (buf, ", uses APCS/float");
2721               break;
2722
2723             case EF_ARM_PIC:
2724               strcat (buf, ", position independent");
2725               break;
2726
2727             case EF_ARM_ALIGN8:
2728               strcat (buf, ", 8 bit structure alignment");
2729               break;
2730
2731             case EF_ARM_NEW_ABI:
2732               strcat (buf, ", uses new ABI");
2733               break;
2734
2735             case EF_ARM_OLD_ABI:
2736               strcat (buf, ", uses old ABI");
2737               break;
2738
2739             case EF_ARM_SOFT_FLOAT:
2740               strcat (buf, ", software FP");
2741               break;
2742
2743             case EF_ARM_VFP_FLOAT:
2744               strcat (buf, ", VFP");
2745               break;
2746
2747             case EF_ARM_MAVERICK_FLOAT:
2748               strcat (buf, ", Maverick FP");
2749               break;
2750
2751             default:
2752               unknown = TRUE;
2753               break;
2754             }
2755         }
2756     }
2757
2758   if (unknown)
2759     strcat (buf,_(", <unknown>"));
2760 }
2761
2762 static void
2763 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2764 {
2765   --size; /* Leave space for null terminator.  */
2766
2767   switch (e_flags & EF_AVR_MACH)
2768     {
2769     case E_AVR_MACH_AVR1:
2770       strncat (buf, ", avr:1", size);
2771       break;
2772     case E_AVR_MACH_AVR2:
2773       strncat (buf, ", avr:2", size);
2774       break;
2775     case E_AVR_MACH_AVR25:
2776       strncat (buf, ", avr:25", size);
2777       break;
2778     case E_AVR_MACH_AVR3:
2779       strncat (buf, ", avr:3", size);
2780       break;
2781     case E_AVR_MACH_AVR31:
2782       strncat (buf, ", avr:31", size);
2783       break;
2784     case E_AVR_MACH_AVR35:
2785       strncat (buf, ", avr:35", size);
2786       break;
2787     case E_AVR_MACH_AVR4:
2788       strncat (buf, ", avr:4", size);
2789       break;
2790     case E_AVR_MACH_AVR5:
2791       strncat (buf, ", avr:5", size);
2792       break;
2793     case E_AVR_MACH_AVR51:
2794       strncat (buf, ", avr:51", size);
2795       break;
2796     case E_AVR_MACH_AVR6:
2797       strncat (buf, ", avr:6", size);
2798       break;
2799     case E_AVR_MACH_AVRTINY:
2800       strncat (buf, ", avr:100", size);
2801       break;
2802     case E_AVR_MACH_XMEGA1:
2803       strncat (buf, ", avr:101", size);
2804       break;
2805     case E_AVR_MACH_XMEGA2:
2806       strncat (buf, ", avr:102", size);
2807       break;
2808     case E_AVR_MACH_XMEGA3:
2809       strncat (buf, ", avr:103", size);
2810       break;
2811     case E_AVR_MACH_XMEGA4:
2812       strncat (buf, ", avr:104", size);
2813       break;
2814     case E_AVR_MACH_XMEGA5:
2815       strncat (buf, ", avr:105", size);
2816       break;
2817     case E_AVR_MACH_XMEGA6:
2818       strncat (buf, ", avr:106", size);
2819       break;
2820     case E_AVR_MACH_XMEGA7:
2821       strncat (buf, ", avr:107", size);
2822       break;
2823     default:
2824       strncat (buf, ", avr:<unknown>", size);
2825       break;
2826     }
2827
2828   size -= strlen (buf);
2829   if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2830     strncat (buf, ", link-relax", size);
2831 }
2832
2833 static void
2834 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2835 {
2836   unsigned abi;
2837   unsigned arch;
2838   unsigned config;
2839   unsigned version;
2840   bfd_boolean has_fpu = FALSE;
2841   unsigned int r = 0;
2842
2843   static const char *ABI_STRINGS[] =
2844   {
2845     "ABI v0", /* use r5 as return register; only used in N1213HC */
2846     "ABI v1", /* use r0 as return register */
2847     "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2848     "ABI v2fp", /* for FPU */
2849     "AABI",
2850     "ABI2 FP+"
2851   };
2852   static const char *VER_STRINGS[] =
2853   {
2854     "Andes ELF V1.3 or older",
2855     "Andes ELF V1.3.1",
2856     "Andes ELF V1.4"
2857   };
2858   static const char *ARCH_STRINGS[] =
2859   {
2860     "",
2861     "Andes Star v1.0",
2862     "Andes Star v2.0",
2863     "Andes Star v3.0",
2864     "Andes Star v3.0m"
2865   };
2866
2867   abi = EF_NDS_ABI & e_flags;
2868   arch = EF_NDS_ARCH & e_flags;
2869   config = EF_NDS_INST & e_flags;
2870   version = EF_NDS32_ELF_VERSION & e_flags;
2871
2872   memset (buf, 0, size);
2873
2874   switch (abi)
2875     {
2876     case E_NDS_ABI_V0:
2877     case E_NDS_ABI_V1:
2878     case E_NDS_ABI_V2:
2879     case E_NDS_ABI_V2FP:
2880     case E_NDS_ABI_AABI:
2881     case E_NDS_ABI_V2FP_PLUS:
2882       /* In case there are holes in the array.  */
2883       r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2884       break;
2885
2886     default:
2887       r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2888       break;
2889     }
2890
2891   switch (version)
2892     {
2893     case E_NDS32_ELF_VER_1_2:
2894     case E_NDS32_ELF_VER_1_3:
2895     case E_NDS32_ELF_VER_1_4:
2896       r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2897       break;
2898
2899     default:
2900       r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2901       break;
2902     }
2903
2904   if (E_NDS_ABI_V0 == abi)
2905     {
2906       /* OLD ABI; only used in N1213HC, has performance extension 1.  */
2907       r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2908       if (arch == E_NDS_ARCH_STAR_V1_0)
2909         r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2910       return;
2911     }
2912
2913   switch (arch)
2914     {
2915     case E_NDS_ARCH_STAR_V1_0:
2916     case E_NDS_ARCH_STAR_V2_0:
2917     case E_NDS_ARCH_STAR_V3_0:
2918     case E_NDS_ARCH_STAR_V3_M:
2919       r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2920       break;
2921
2922     default:
2923       r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2924       /* ARCH version determines how the e_flags are interpreted.
2925          If it is unknown, we cannot proceed.  */
2926       return;
2927     }
2928
2929   /* Newer ABI; Now handle architecture specific flags.  */
2930   if (arch == E_NDS_ARCH_STAR_V1_0)
2931     {
2932       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2933         r += snprintf (buf + r, size -r, ", MFUSR_PC");
2934
2935       if (!(config & E_NDS32_HAS_NO_MAC_INST))
2936         r += snprintf (buf + r, size -r, ", MAC");
2937
2938       if (config & E_NDS32_HAS_DIV_INST)
2939         r += snprintf (buf + r, size -r, ", DIV");
2940
2941       if (config & E_NDS32_HAS_16BIT_INST)
2942         r += snprintf (buf + r, size -r, ", 16b");
2943     }
2944   else
2945     {
2946       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2947         {
2948           if (version <= E_NDS32_ELF_VER_1_3)
2949             r += snprintf (buf + r, size -r, ", [B8]");
2950           else
2951             r += snprintf (buf + r, size -r, ", EX9");
2952         }
2953
2954       if (config & E_NDS32_HAS_MAC_DX_INST)
2955         r += snprintf (buf + r, size -r, ", MAC_DX");
2956
2957       if (config & E_NDS32_HAS_DIV_DX_INST)
2958         r += snprintf (buf + r, size -r, ", DIV_DX");
2959
2960       if (config & E_NDS32_HAS_16BIT_INST)
2961         {
2962           if (version <= E_NDS32_ELF_VER_1_3)
2963             r += snprintf (buf + r, size -r, ", 16b");
2964           else
2965             r += snprintf (buf + r, size -r, ", IFC");
2966         }
2967     }
2968
2969   if (config & E_NDS32_HAS_EXT_INST)
2970     r += snprintf (buf + r, size -r, ", PERF1");
2971
2972   if (config & E_NDS32_HAS_EXT2_INST)
2973     r += snprintf (buf + r, size -r, ", PERF2");
2974
2975   if (config & E_NDS32_HAS_FPU_INST)
2976     {
2977       has_fpu = TRUE;
2978       r += snprintf (buf + r, size -r, ", FPU_SP");
2979     }
2980
2981   if (config & E_NDS32_HAS_FPU_DP_INST)
2982     {
2983       has_fpu = TRUE;
2984       r += snprintf (buf + r, size -r, ", FPU_DP");
2985     }
2986
2987   if (config & E_NDS32_HAS_FPU_MAC_INST)
2988     {
2989       has_fpu = TRUE;
2990       r += snprintf (buf + r, size -r, ", FPU_MAC");
2991     }
2992
2993   if (has_fpu)
2994     {
2995       switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2996         {
2997         case E_NDS32_FPU_REG_8SP_4DP:
2998           r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2999           break;
3000         case E_NDS32_FPU_REG_16SP_8DP:
3001           r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
3002           break;
3003         case E_NDS32_FPU_REG_32SP_16DP:
3004           r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
3005           break;
3006         case E_NDS32_FPU_REG_32SP_32DP:
3007           r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
3008           break;
3009         }
3010     }
3011
3012   if (config & E_NDS32_HAS_AUDIO_INST)
3013     r += snprintf (buf + r, size -r, ", AUDIO");
3014
3015   if (config & E_NDS32_HAS_STRING_INST)
3016     r += snprintf (buf + r, size -r, ", STR");
3017
3018   if (config & E_NDS32_HAS_REDUCED_REGS)
3019     r += snprintf (buf + r, size -r, ", 16REG");
3020
3021   if (config & E_NDS32_HAS_VIDEO_INST)
3022     {
3023       if (version <= E_NDS32_ELF_VER_1_3)
3024         r += snprintf (buf + r, size -r, ", VIDEO");
3025       else
3026         r += snprintf (buf + r, size -r, ", SATURATION");
3027     }
3028
3029   if (config & E_NDS32_HAS_ENCRIPT_INST)
3030     r += snprintf (buf + r, size -r, ", ENCRP");
3031
3032   if (config & E_NDS32_HAS_L2C_INST)
3033     r += snprintf (buf + r, size -r, ", L2C");
3034 }
3035
3036 static char *
3037 get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine)
3038 {
3039   static char buf[1024];
3040
3041   buf[0] = '\0';
3042
3043   if (e_flags)
3044     {
3045       switch (e_machine)
3046         {
3047         default:
3048           break;
3049
3050         case EM_ARC_COMPACT2:
3051         case EM_ARC_COMPACT:
3052           decode_ARC_machine_flags (e_flags, e_machine, buf);
3053           break;
3054
3055         case EM_ARM:
3056           decode_ARM_machine_flags (e_flags, buf);
3057           break;
3058
3059         case EM_AVR:
3060           decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3061           break;
3062
3063         case EM_BLACKFIN:
3064           if (e_flags & EF_BFIN_PIC)
3065             strcat (buf, ", PIC");
3066
3067           if (e_flags & EF_BFIN_FDPIC)
3068             strcat (buf, ", FDPIC");
3069
3070           if (e_flags & EF_BFIN_CODE_IN_L1)
3071             strcat (buf, ", code in L1");
3072
3073           if (e_flags & EF_BFIN_DATA_IN_L1)
3074             strcat (buf, ", data in L1");
3075
3076           break;
3077
3078         case EM_CYGNUS_FRV:
3079           switch (e_flags & EF_FRV_CPU_MASK)
3080             {
3081             case EF_FRV_CPU_GENERIC:
3082               break;
3083
3084             default:
3085               strcat (buf, ", fr???");
3086               break;
3087
3088             case EF_FRV_CPU_FR300:
3089               strcat (buf, ", fr300");
3090               break;
3091
3092             case EF_FRV_CPU_FR400:
3093               strcat (buf, ", fr400");
3094               break;
3095             case EF_FRV_CPU_FR405:
3096               strcat (buf, ", fr405");
3097               break;
3098
3099             case EF_FRV_CPU_FR450:
3100               strcat (buf, ", fr450");
3101               break;
3102
3103             case EF_FRV_CPU_FR500:
3104               strcat (buf, ", fr500");
3105               break;
3106             case EF_FRV_CPU_FR550:
3107               strcat (buf, ", fr550");
3108               break;
3109
3110             case EF_FRV_CPU_SIMPLE:
3111               strcat (buf, ", simple");
3112               break;
3113             case EF_FRV_CPU_TOMCAT:
3114               strcat (buf, ", tomcat");
3115               break;
3116             }
3117           break;
3118
3119         case EM_68K:
3120           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3121             strcat (buf, ", m68000");
3122           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3123             strcat (buf, ", cpu32");
3124           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3125             strcat (buf, ", fido_a");
3126           else
3127             {
3128               char const * isa = _("unknown");
3129               char const * mac = _("unknown mac");
3130               char const * additional = NULL;
3131
3132               switch (e_flags & EF_M68K_CF_ISA_MASK)
3133                 {
3134                 case EF_M68K_CF_ISA_A_NODIV:
3135                   isa = "A";
3136                   additional = ", nodiv";
3137                   break;
3138                 case EF_M68K_CF_ISA_A:
3139                   isa = "A";
3140                   break;
3141                 case EF_M68K_CF_ISA_A_PLUS:
3142                   isa = "A+";
3143                   break;
3144                 case EF_M68K_CF_ISA_B_NOUSP:
3145                   isa = "B";
3146                   additional = ", nousp";
3147                   break;
3148                 case EF_M68K_CF_ISA_B:
3149                   isa = "B";
3150                   break;
3151                 case EF_M68K_CF_ISA_C:
3152                   isa = "C";
3153                   break;
3154                 case EF_M68K_CF_ISA_C_NODIV:
3155                   isa = "C";
3156                   additional = ", nodiv";
3157                   break;
3158                 }
3159               strcat (buf, ", cf, isa ");
3160               strcat (buf, isa);
3161               if (additional)
3162                 strcat (buf, additional);
3163               if (e_flags & EF_M68K_CF_FLOAT)
3164                 strcat (buf, ", float");
3165               switch (e_flags & EF_M68K_CF_MAC_MASK)
3166                 {
3167                 case 0:
3168                   mac = NULL;
3169                   break;
3170                 case EF_M68K_CF_MAC:
3171                   mac = "mac";
3172                   break;
3173                 case EF_M68K_CF_EMAC:
3174                   mac = "emac";
3175                   break;
3176                 case EF_M68K_CF_EMAC_B:
3177                   mac = "emac_b";
3178                   break;
3179                 }
3180               if (mac)
3181                 {
3182                   strcat (buf, ", ");
3183                   strcat (buf, mac);
3184                 }
3185             }
3186           break;
3187
3188         case EM_CYGNUS_MEP:
3189           switch (e_flags & EF_MEP_CPU_MASK)
3190             {
3191             case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3192             case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3193             case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3194             case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3195             case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3196             case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3197             default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3198             }
3199
3200           switch (e_flags & EF_MEP_COP_MASK)
3201             {
3202             case EF_MEP_COP_NONE: break;
3203             case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3204             case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3205             case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3206             case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3207             default: strcat (buf, _("<unknown MeP copro type>")); break;
3208             }
3209
3210           if (e_flags & EF_MEP_LIBRARY)
3211             strcat (buf, ", Built for Library");
3212
3213           if (e_flags & EF_MEP_INDEX_MASK)
3214             sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3215                      e_flags & EF_MEP_INDEX_MASK);
3216
3217           if (e_flags & ~ EF_MEP_ALL_FLAGS)
3218             sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3219                      e_flags & ~ EF_MEP_ALL_FLAGS);
3220           break;
3221
3222         case EM_PPC:
3223           if (e_flags & EF_PPC_EMB)
3224             strcat (buf, ", emb");
3225
3226           if (e_flags & EF_PPC_RELOCATABLE)
3227             strcat (buf, _(", relocatable"));
3228
3229           if (e_flags & EF_PPC_RELOCATABLE_LIB)
3230             strcat (buf, _(", relocatable-lib"));
3231           break;
3232
3233         case EM_PPC64:
3234           if (e_flags & EF_PPC64_ABI)
3235             {
3236               char abi[] = ", abiv0";
3237
3238               abi[6] += e_flags & EF_PPC64_ABI;
3239               strcat (buf, abi);
3240             }
3241           break;
3242
3243         case EM_V800:
3244           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3245             strcat (buf, ", RH850 ABI");
3246
3247           if (e_flags & EF_V800_850E3)
3248             strcat (buf, ", V3 architecture");
3249
3250           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3251             strcat (buf, ", FPU not used");
3252
3253           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3254             strcat (buf, ", regmode: COMMON");
3255
3256           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3257             strcat (buf, ", r4 not used");
3258
3259           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3260             strcat (buf, ", r30 not used");
3261
3262           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3263             strcat (buf, ", r5 not used");
3264
3265           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3266             strcat (buf, ", r2 not used");
3267
3268           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3269             {
3270               switch (e_flags & - e_flags)
3271                 {
3272                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3273                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3274                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3275                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3276                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3277                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3278                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3279                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3280                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3281                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3282                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3283                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3284                 default: break;
3285                 }
3286             }
3287           break;
3288
3289         case EM_V850:
3290         case EM_CYGNUS_V850:
3291           switch (e_flags & EF_V850_ARCH)
3292             {
3293             case E_V850E3V5_ARCH:
3294               strcat (buf, ", v850e3v5");
3295               break;
3296             case E_V850E2V3_ARCH:
3297               strcat (buf, ", v850e2v3");
3298               break;
3299             case E_V850E2_ARCH:
3300               strcat (buf, ", v850e2");
3301               break;
3302             case E_V850E1_ARCH:
3303               strcat (buf, ", v850e1");
3304               break;
3305             case E_V850E_ARCH:
3306               strcat (buf, ", v850e");
3307               break;
3308             case E_V850_ARCH:
3309               strcat (buf, ", v850");
3310               break;
3311             default:
3312               strcat (buf, _(", unknown v850 architecture variant"));
3313               break;
3314             }
3315           break;
3316
3317         case EM_M32R:
3318         case EM_CYGNUS_M32R:
3319           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3320             strcat (buf, ", m32r");
3321           break;
3322
3323         case EM_MIPS:
3324         case EM_MIPS_RS3_LE:
3325           if (e_flags & EF_MIPS_NOREORDER)
3326             strcat (buf, ", noreorder");
3327
3328           if (e_flags & EF_MIPS_PIC)
3329             strcat (buf, ", pic");
3330
3331           if (e_flags & EF_MIPS_CPIC)
3332             strcat (buf, ", cpic");
3333
3334           if (e_flags & EF_MIPS_UCODE)
3335             strcat (buf, ", ugen_reserved");
3336
3337           if (e_flags & EF_MIPS_ABI2)
3338             strcat (buf, ", abi2");
3339
3340           if (e_flags & EF_MIPS_OPTIONS_FIRST)
3341             strcat (buf, ", odk first");
3342
3343           if (e_flags & EF_MIPS_32BITMODE)
3344             strcat (buf, ", 32bitmode");
3345
3346           if (e_flags & EF_MIPS_NAN2008)
3347             strcat (buf, ", nan2008");
3348
3349           if (e_flags & EF_MIPS_FP64)
3350             strcat (buf, ", fp64");
3351
3352           switch ((e_flags & EF_MIPS_MACH))
3353             {
3354             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3355             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3356             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3357             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3358             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3359             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3360             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3361             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3362             case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break;
3363             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
3364             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3365             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3366             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3367             case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
3368             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3369             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3370             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3371             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
3372             case E_MIPS_MACH_IAMR2:  strcat (buf, ", interaptiv-mr2"); break;
3373             case 0:
3374             /* We simply ignore the field in this case to avoid confusion:
3375                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3376                extension.  */
3377               break;
3378             default: strcat (buf, _(", unknown CPU")); break;
3379             }
3380
3381           switch ((e_flags & EF_MIPS_ABI))
3382             {
3383             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3384             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3385             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3386             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3387             case 0:
3388             /* We simply ignore the field in this case to avoid confusion:
3389                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3390                This means it is likely to be an o32 file, but not for
3391                sure.  */
3392               break;
3393             default: strcat (buf, _(", unknown ABI")); break;
3394             }
3395
3396           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3397             strcat (buf, ", mdmx");
3398
3399           if (e_flags & EF_MIPS_ARCH_ASE_M16)
3400             strcat (buf, ", mips16");
3401
3402           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3403             strcat (buf, ", micromips");
3404
3405           switch ((e_flags & EF_MIPS_ARCH))
3406             {
3407             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3408             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3409             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3410             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3411             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3412             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3413             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3414             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3415             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3416             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3417             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3418             default: strcat (buf, _(", unknown ISA")); break;
3419             }
3420           break;
3421
3422         case EM_NDS32:
3423           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3424           break;
3425
3426         case EM_RISCV:
3427           if (e_flags & EF_RISCV_RVC)
3428             strcat (buf, ", RVC");
3429
3430           switch (e_flags & EF_RISCV_FLOAT_ABI)
3431             {
3432             case EF_RISCV_FLOAT_ABI_SOFT:
3433               strcat (buf, ", soft-float ABI");
3434               break;
3435
3436             case EF_RISCV_FLOAT_ABI_SINGLE:
3437               strcat (buf, ", single-float ABI");
3438               break;
3439
3440             case EF_RISCV_FLOAT_ABI_DOUBLE:
3441               strcat (buf, ", double-float ABI");
3442               break;
3443
3444             case EF_RISCV_FLOAT_ABI_QUAD:
3445               strcat (buf, ", quad-float ABI");
3446               break;
3447             }
3448           break;
3449
3450         case EM_SH:
3451           switch ((e_flags & EF_SH_MACH_MASK))
3452             {
3453             case EF_SH1: strcat (buf, ", sh1"); break;
3454             case EF_SH2: strcat (buf, ", sh2"); break;
3455             case EF_SH3: strcat (buf, ", sh3"); break;
3456             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3457             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3458             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3459             case EF_SH3E: strcat (buf, ", sh3e"); break;
3460             case EF_SH4: strcat (buf, ", sh4"); break;
3461             case EF_SH5: strcat (buf, ", sh5"); break;
3462             case EF_SH2E: strcat (buf, ", sh2e"); break;
3463             case EF_SH4A: strcat (buf, ", sh4a"); break;
3464             case EF_SH2A: strcat (buf, ", sh2a"); break;
3465             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3466             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3467             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3468             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3469             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3470             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3471             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3472             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3473             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3474             default: strcat (buf, _(", unknown ISA")); break;
3475             }
3476
3477           if (e_flags & EF_SH_PIC)
3478             strcat (buf, ", pic");
3479
3480           if (e_flags & EF_SH_FDPIC)
3481             strcat (buf, ", fdpic");
3482           break;
3483
3484         case EM_OR1K:
3485           if (e_flags & EF_OR1K_NODELAY)
3486             strcat (buf, ", no delay");
3487           break;
3488
3489         case EM_SPARCV9:
3490           if (e_flags & EF_SPARC_32PLUS)
3491             strcat (buf, ", v8+");
3492
3493           if (e_flags & EF_SPARC_SUN_US1)
3494             strcat (buf, ", ultrasparcI");
3495
3496           if (e_flags & EF_SPARC_SUN_US3)
3497             strcat (buf, ", ultrasparcIII");
3498
3499           if (e_flags & EF_SPARC_HAL_R1)
3500             strcat (buf, ", halr1");
3501
3502           if (e_flags & EF_SPARC_LEDATA)
3503             strcat (buf, ", ledata");
3504
3505           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3506             strcat (buf, ", tso");
3507
3508           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3509             strcat (buf, ", pso");
3510
3511           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3512             strcat (buf, ", rmo");
3513           break;
3514
3515         case EM_PARISC:
3516           switch (e_flags & EF_PARISC_ARCH)
3517             {
3518             case EFA_PARISC_1_0:
3519               strcpy (buf, ", PA-RISC 1.0");
3520               break;
3521             case EFA_PARISC_1_1:
3522               strcpy (buf, ", PA-RISC 1.1");
3523               break;
3524             case EFA_PARISC_2_0:
3525               strcpy (buf, ", PA-RISC 2.0");
3526               break;
3527             default:
3528               break;
3529             }
3530           if (e_flags & EF_PARISC_TRAPNIL)
3531             strcat (buf, ", trapnil");
3532           if (e_flags & EF_PARISC_EXT)
3533             strcat (buf, ", ext");
3534           if (e_flags & EF_PARISC_LSB)
3535             strcat (buf, ", lsb");
3536           if (e_flags & EF_PARISC_WIDE)
3537             strcat (buf, ", wide");
3538           if (e_flags & EF_PARISC_NO_KABP)
3539             strcat (buf, ", no kabp");
3540           if (e_flags & EF_PARISC_LAZYSWAP)
3541             strcat (buf, ", lazyswap");
3542           break;
3543
3544         case EM_PJ:
3545         case EM_PJ_OLD:
3546           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3547             strcat (buf, ", new calling convention");
3548
3549           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3550             strcat (buf, ", gnu calling convention");
3551           break;
3552
3553         case EM_IA_64:
3554           if ((e_flags & EF_IA_64_ABI64))
3555             strcat (buf, ", 64-bit");
3556           else
3557             strcat (buf, ", 32-bit");
3558           if ((e_flags & EF_IA_64_REDUCEDFP))
3559             strcat (buf, ", reduced fp model");
3560           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3561             strcat (buf, ", no function descriptors, constant gp");
3562           else if ((e_flags & EF_IA_64_CONS_GP))
3563             strcat (buf, ", constant gp");
3564           if ((e_flags & EF_IA_64_ABSOLUTE))
3565             strcat (buf, ", absolute");
3566           if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3567             {
3568               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3569                 strcat (buf, ", vms_linkages");
3570               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3571                 {
3572                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3573                   break;
3574                 case EF_IA_64_VMS_COMCOD_WARNING:
3575                   strcat (buf, ", warning");
3576                   break;
3577                 case EF_IA_64_VMS_COMCOD_ERROR:
3578                   strcat (buf, ", error");
3579                   break;
3580                 case EF_IA_64_VMS_COMCOD_ABORT:
3581                   strcat (buf, ", abort");
3582                   break;
3583                 default:
3584                   warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3585                         e_flags & EF_IA_64_VMS_COMCOD);
3586                   strcat (buf, ", <unknown>");
3587                 }
3588             }
3589           break;
3590
3591         case EM_VAX:
3592           if ((e_flags & EF_VAX_NONPIC))
3593             strcat (buf, ", non-PIC");
3594           if ((e_flags & EF_VAX_DFLOAT))
3595             strcat (buf, ", D-Float");
3596           if ((e_flags & EF_VAX_GFLOAT))
3597             strcat (buf, ", G-Float");
3598           break;
3599
3600         case EM_VISIUM:
3601           if (e_flags & EF_VISIUM_ARCH_MCM)
3602             strcat (buf, ", mcm");
3603           else if (e_flags & EF_VISIUM_ARCH_MCM24)
3604             strcat (buf, ", mcm24");
3605           if (e_flags & EF_VISIUM_ARCH_GR6)
3606             strcat (buf, ", gr6");
3607           break;
3608
3609         case EM_RL78:
3610           switch (e_flags & E_FLAG_RL78_CPU_MASK)
3611             {
3612             case E_FLAG_RL78_ANY_CPU: break;
3613             case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3614             case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3615             case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3616             }
3617           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3618             strcat (buf, ", 64-bit doubles");
3619           break;
3620
3621         case EM_RX:
3622           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3623             strcat (buf, ", 64-bit doubles");
3624           if (e_flags & E_FLAG_RX_DSP)
3625             strcat (buf, ", dsp");
3626           if (e_flags & E_FLAG_RX_PID)
3627             strcat (buf, ", pid");
3628           if (e_flags & E_FLAG_RX_ABI)
3629             strcat (buf, ", RX ABI");
3630           if (e_flags & E_FLAG_RX_SINSNS_SET)
3631             strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3632                     ? ", uses String instructions" : ", bans String instructions");
3633           if (e_flags & E_FLAG_RX_V2)
3634             strcat (buf, ", V2");
3635           break;
3636
3637         case EM_S390:
3638           if (e_flags & EF_S390_HIGH_GPRS)
3639             strcat (buf, ", highgprs");
3640           break;
3641
3642         case EM_TI_C6000:
3643           if ((e_flags & EF_C6000_REL))
3644             strcat (buf, ", relocatable module");
3645           break;
3646
3647         case EM_MSP430:
3648           strcat (buf, _(": architecture variant: "));
3649           switch (e_flags & EF_MSP430_MACH)
3650             {
3651             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3652             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3653             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3654             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3655             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3656             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3657             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3658             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3659             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3660             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3661             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3662             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3663             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3664             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3665             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3666             default:
3667               strcat (buf, _(": unknown")); break;
3668             }
3669
3670           if (e_flags & ~ EF_MSP430_MACH)
3671             strcat (buf, _(": unknown extra flag bits also present"));
3672         }
3673     }
3674
3675   return buf;
3676 }
3677
3678 static const char *
3679 get_osabi_name (Filedata * filedata, unsigned int osabi)
3680 {
3681   static char buff[32];
3682
3683   switch (osabi)
3684     {
3685     case ELFOSABI_NONE:         return "UNIX - System V";
3686     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3687     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3688     case ELFOSABI_GNU:          return "UNIX - GNU";
3689     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3690     case ELFOSABI_AIX:          return "UNIX - AIX";
3691     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3692     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3693     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3694     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3695     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3696     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3697     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3698     case ELFOSABI_AROS:         return "AROS";
3699     case ELFOSABI_FENIXOS:      return "FenixOS";
3700     case ELFOSABI_CLOUDABI:     return "Nuxi CloudABI";
3701     case ELFOSABI_OPENVOS:      return "Stratus Technologies OpenVOS";
3702     default:
3703       if (osabi >= 64)
3704         switch (filedata->file_header.e_machine)
3705           {
3706           case EM_ARM:
3707             switch (osabi)
3708               {
3709               case ELFOSABI_ARM:        return "ARM";
3710               default:
3711                 break;
3712               }
3713             break;
3714
3715           case EM_MSP430:
3716           case EM_MSP430_OLD:
3717           case EM_VISIUM:
3718             switch (osabi)
3719               {
3720               case ELFOSABI_STANDALONE: return _("Standalone App");
3721               default:
3722                 break;
3723               }
3724             break;
3725
3726           case EM_TI_C6000:
3727             switch (osabi)
3728               {
3729               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3730               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3731               default:
3732                 break;
3733               }
3734             break;
3735
3736           default:
3737             break;
3738           }
3739       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3740       return buff;
3741     }
3742 }
3743
3744 static const char *
3745 get_aarch64_segment_type (unsigned long type)
3746 {
3747   switch (type)
3748     {
3749     case PT_AARCH64_ARCHEXT:  return "AARCH64_ARCHEXT";
3750     default:                  return NULL;
3751     }
3752 }
3753
3754 static const char *
3755 get_arm_segment_type (unsigned long type)
3756 {
3757   switch (type)
3758     {
3759     case PT_ARM_EXIDX: return "EXIDX";
3760     default:           return NULL;
3761     }
3762 }
3763
3764 static const char *
3765 get_s390_segment_type (unsigned long type)
3766 {
3767   switch (type)
3768     {
3769     case PT_S390_PGSTE: return "S390_PGSTE";
3770     default:            return NULL;
3771     }
3772 }
3773
3774 static const char *
3775 get_mips_segment_type (unsigned long type)
3776 {
3777   switch (type)
3778     {
3779     case PT_MIPS_REGINFO:   return "REGINFO";
3780     case PT_MIPS_RTPROC:    return "RTPROC";
3781     case PT_MIPS_OPTIONS:   return "OPTIONS";
3782     case PT_MIPS_ABIFLAGS:  return "ABIFLAGS";
3783     default:                return NULL;
3784     }
3785 }
3786
3787 static const char *
3788 get_parisc_segment_type (unsigned long type)
3789 {
3790   switch (type)
3791     {
3792     case PT_HP_TLS:             return "HP_TLS";
3793     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3794     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3795     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3796     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3797     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3798     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3799     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3800     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3801     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3802     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3803     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3804     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3805     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3806     case PT_HP_STACK:           return "HP_STACK";
3807     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3808     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3809     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3810     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3811     default:                    return NULL;
3812     }
3813 }
3814
3815 static const char *
3816 get_ia64_segment_type (unsigned long type)
3817 {
3818   switch (type)
3819     {
3820     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3821     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3822     case PT_HP_TLS:             return "HP_TLS";
3823     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3824     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3825     case PT_IA_64_HP_STACK:     return "HP_STACK";
3826     default:                    return NULL;
3827     }
3828 }
3829
3830 static const char *
3831 get_tic6x_segment_type (unsigned long type)
3832 {
3833   switch (type)
3834     {
3835     case PT_C6000_PHATTR:  return "C6000_PHATTR";
3836     default:               return NULL;
3837     }
3838 }
3839
3840 static const char *
3841 get_solaris_segment_type (unsigned long type)
3842 {
3843   switch (type)
3844     {
3845     case 0x6464e550: return "PT_SUNW_UNWIND";
3846     case 0x6474e550: return "PT_SUNW_EH_FRAME";
3847     case 0x6ffffff7: return "PT_LOSUNW";
3848     case 0x6ffffffa: return "PT_SUNWBSS";
3849     case 0x6ffffffb: return "PT_SUNWSTACK";
3850     case 0x6ffffffc: return "PT_SUNWDTRACE";
3851     case 0x6ffffffd: return "PT_SUNWCAP";
3852     case 0x6fffffff: return "PT_HISUNW";
3853     default:         return NULL;
3854     }
3855 }
3856
3857 static const char *
3858 get_segment_type (Filedata * filedata, unsigned long p_type)
3859 {
3860   static char buff[32];
3861
3862   switch (p_type)
3863     {
3864     case PT_NULL:       return "NULL";
3865     case PT_LOAD:       return "LOAD";
3866     case PT_DYNAMIC:    return "DYNAMIC";
3867     case PT_INTERP:     return "INTERP";
3868     case PT_NOTE:       return "NOTE";
3869     case PT_SHLIB:      return "SHLIB";
3870     case PT_PHDR:       return "PHDR";
3871     case PT_TLS:        return "TLS";
3872     case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3873     case PT_GNU_STACK:  return "GNU_STACK";
3874     case PT_GNU_RELRO:  return "GNU_RELRO";
3875
3876     default:
3877       if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
3878         {
3879           sprintf (buff, "GNU_MBIND+%#lx",
3880                    p_type - PT_GNU_MBIND_LO);
3881         }
3882       else if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3883         {
3884           const char * result;
3885
3886           switch (filedata->file_header.e_machine)
3887             {
3888             case EM_AARCH64:
3889               result = get_aarch64_segment_type (p_type);
3890               break;
3891             case EM_ARM:
3892               result = get_arm_segment_type (p_type);
3893               break;
3894             case EM_MIPS:
3895             case EM_MIPS_RS3_LE:
3896               result = get_mips_segment_type (p_type);
3897               break;
3898             case EM_PARISC:
3899               result = get_parisc_segment_type (p_type);
3900               break;
3901             case EM_IA_64:
3902               result = get_ia64_segment_type (p_type);
3903               break;
3904             case EM_TI_C6000:
3905               result = get_tic6x_segment_type (p_type);
3906               break;
3907             case EM_S390:
3908             case EM_S390_OLD:
3909               result = get_s390_segment_type (p_type);
3910               break;
3911             default:
3912               result = NULL;
3913               break;
3914             }
3915
3916           if (result != NULL)
3917             return result;
3918
3919           sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
3920         }
3921       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3922         {
3923           const char * result;
3924
3925           switch (filedata->file_header.e_machine)
3926             {
3927             case EM_PARISC:
3928               result = get_parisc_segment_type (p_type);
3929               break;
3930             case EM_IA_64:
3931               result = get_ia64_segment_type (p_type);
3932               break;
3933             default:
3934               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3935                 result = get_solaris_segment_type (p_type);
3936               else
3937                 result = NULL;
3938               break;
3939             }
3940
3941           if (result != NULL)
3942             return result;
3943
3944           sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
3945         }
3946       else
3947         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3948
3949       return buff;
3950     }
3951 }
3952
3953 static const char *
3954 get_arc_section_type_name (unsigned int sh_type)
3955 {
3956   switch (sh_type)
3957     {
3958     case SHT_ARC_ATTRIBUTES:      return "ARC_ATTRIBUTES";
3959     default:
3960       break;
3961     }
3962   return NULL;
3963 }
3964
3965 static const char *
3966 get_mips_section_type_name (unsigned int sh_type)
3967 {
3968   switch (sh_type)
3969     {
3970     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
3971     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
3972     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
3973     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
3974     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
3975     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
3976     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
3977     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
3978     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
3979     case SHT_MIPS_RELD:          return "MIPS_RELD";
3980     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
3981     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
3982     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
3983     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
3984     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
3985     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
3986     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
3987     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
3988     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
3989     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
3990     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
3991     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
3992     case SHT_MIPS_LINE:          return "MIPS_LINE";
3993     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
3994     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
3995     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
3996     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
3997     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
3998     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
3999     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
4000     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
4001     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
4002     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
4003     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
4004     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
4005     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
4006     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
4007     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
4008     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
4009     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
4010     default:
4011       break;
4012     }
4013   return NULL;
4014 }
4015
4016 static const char *
4017 get_parisc_section_type_name (unsigned int sh_type)
4018 {
4019   switch (sh_type)
4020     {
4021     case SHT_PARISC_EXT:        return "PARISC_EXT";
4022     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
4023     case SHT_PARISC_DOC:        return "PARISC_DOC";
4024     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
4025     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
4026     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
4027     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
4028     default:                    return NULL;
4029     }
4030 }
4031
4032 static const char *
4033 get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
4034 {
4035   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
4036   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4037     return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
4038
4039   switch (sh_type)
4040     {
4041     case SHT_IA_64_EXT:                return "IA_64_EXT";
4042     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
4043     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
4044     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
4045     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4046     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
4047     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
4048     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
4049     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
4050     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
4051     default:
4052       break;
4053     }
4054   return NULL;
4055 }
4056
4057 static const char *
4058 get_x86_64_section_type_name (unsigned int sh_type)
4059 {
4060   switch (sh_type)
4061     {
4062     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
4063     default:                    return NULL;
4064     }
4065 }
4066
4067 static const char *
4068 get_aarch64_section_type_name (unsigned int sh_type)
4069 {
4070   switch (sh_type)
4071     {
4072     case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4073     default:                     return NULL;
4074     }
4075 }
4076
4077 static const char *
4078 get_arm_section_type_name (unsigned int sh_type)
4079 {
4080   switch (sh_type)
4081     {
4082     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
4083     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
4084     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
4085     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
4086     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
4087     default:                      return NULL;
4088     }
4089 }
4090
4091 static const char *
4092 get_tic6x_section_type_name (unsigned int sh_type)
4093 {
4094   switch (sh_type)
4095     {
4096     case SHT_C6000_UNWIND:      return "C6000_UNWIND";
4097     case SHT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
4098     case SHT_C6000_ATTRIBUTES:  return "C6000_ATTRIBUTES";
4099     case SHT_TI_ICODE:          return "TI_ICODE";
4100     case SHT_TI_XREF:           return "TI_XREF";
4101     case SHT_TI_HANDLER:        return "TI_HANDLER";
4102     case SHT_TI_INITINFO:       return "TI_INITINFO";
4103     case SHT_TI_PHATTRS:        return "TI_PHATTRS";
4104     default:                    return NULL;
4105     }
4106 }
4107
4108 static const char *
4109 get_msp430x_section_type_name (unsigned int sh_type)
4110 {
4111   switch (sh_type)
4112     {
4113     case SHT_MSP430_SEC_FLAGS:    return "MSP430_SEC_FLAGS";
4114     case SHT_MSP430_SYM_ALIASES:  return "MSP430_SYM_ALIASES";
4115     case SHT_MSP430_ATTRIBUTES:   return "MSP430_ATTRIBUTES";
4116     default:                      return NULL;
4117     }
4118 }
4119
4120 static const char *
4121 get_v850_section_type_name (unsigned int sh_type)
4122 {
4123   switch (sh_type)
4124     {
4125     case SHT_V850_SCOMMON:  return "V850 Small Common";
4126     case SHT_V850_TCOMMON:  return "V850 Tiny Common";
4127     case SHT_V850_ZCOMMON:  return "V850 Zero Common";
4128     case SHT_RENESAS_IOP:   return "RENESAS IOP";
4129     case SHT_RENESAS_INFO:  return "RENESAS INFO";
4130     default:                return NULL;
4131     }
4132 }
4133
4134 static const char *
4135 get_section_type_name (Filedata * filedata, unsigned int sh_type)
4136 {
4137   static char buff[32];
4138   const char * result;
4139
4140   switch (sh_type)
4141     {
4142     case SHT_NULL:              return "NULL";
4143     case SHT_PROGBITS:          return "PROGBITS";
4144     case SHT_SYMTAB:            return "SYMTAB";
4145     case SHT_STRTAB:            return "STRTAB";
4146     case SHT_RELA:              return "RELA";
4147     case SHT_HASH:              return "HASH";
4148     case SHT_DYNAMIC:           return "DYNAMIC";
4149     case SHT_NOTE:              return "NOTE";
4150     case SHT_NOBITS:            return "NOBITS";
4151     case SHT_REL:               return "REL";
4152     case SHT_SHLIB:             return "SHLIB";
4153     case SHT_DYNSYM:            return "DYNSYM";
4154     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
4155     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
4156     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
4157     case SHT_GNU_HASH:          return "GNU_HASH";
4158     case SHT_GROUP:             return "GROUP";
4159     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
4160     case SHT_GNU_verdef:        return "VERDEF";
4161     case SHT_GNU_verneed:       return "VERNEED";
4162     case SHT_GNU_versym:        return "VERSYM";
4163     case 0x6ffffff0:            return "VERSYM";
4164     case 0x6ffffffc:            return "VERDEF";
4165     case 0x7ffffffd:            return "AUXILIARY";
4166     case 0x7fffffff:            return "FILTER";
4167     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
4168
4169     default:
4170       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4171         {
4172           switch (filedata->file_header.e_machine)
4173             {
4174             case EM_ARC:
4175             case EM_ARC_COMPACT:
4176             case EM_ARC_COMPACT2:
4177               result = get_arc_section_type_name (sh_type);
4178               break;
4179             case EM_MIPS:
4180             case EM_MIPS_RS3_LE:
4181               result = get_mips_section_type_name (sh_type);
4182               break;
4183             case EM_PARISC:
4184               result = get_parisc_section_type_name (sh_type);
4185               break;
4186             case EM_IA_64:
4187               result = get_ia64_section_type_name (filedata, sh_type);
4188               break;
4189             case EM_X86_64:
4190             case EM_L1OM:
4191             case EM_K1OM:
4192               result = get_x86_64_section_type_name (sh_type);
4193               break;
4194             case EM_AARCH64:
4195               result = get_aarch64_section_type_name (sh_type);
4196               break;
4197             case EM_ARM:
4198               result = get_arm_section_type_name (sh_type);
4199               break;
4200             case EM_TI_C6000:
4201               result = get_tic6x_section_type_name (sh_type);
4202               break;
4203             case EM_MSP430:
4204               result = get_msp430x_section_type_name (sh_type);
4205               break;
4206             case EM_V800:
4207             case EM_V850:
4208             case EM_CYGNUS_V850:
4209               result = get_v850_section_type_name (sh_type);
4210               break;
4211             default:
4212               result = NULL;
4213               break;
4214             }
4215
4216           if (result != NULL)
4217             return result;
4218
4219           sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4220         }
4221       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4222         {
4223           switch (filedata->file_header.e_machine)
4224             {
4225             case EM_IA_64:
4226               result = get_ia64_section_type_name (filedata, sh_type);
4227               break;
4228             default:
4229               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4230                 result = get_solaris_section_type (sh_type);
4231               else
4232                 {
4233                   switch (sh_type)
4234                     {
4235                     case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4236                     case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4237                     case SHT_GNU_HASH: result = "GNU_HASH"; break;
4238                     case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4239                     default:
4240                       result = NULL;
4241                       break;
4242                     }
4243                 }
4244               break;
4245             }
4246
4247           if (result != NULL)
4248             return result;
4249
4250           sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4251         }
4252       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4253         {
4254           switch (filedata->file_header.e_machine)
4255             {
4256             case EM_V800:
4257             case EM_V850:
4258             case EM_CYGNUS_V850:
4259               result = get_v850_section_type_name (sh_type);
4260               break;
4261             default:
4262               result = NULL;
4263               break;
4264             }
4265
4266           if (result != NULL)
4267             return result;
4268
4269           sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4270         }
4271       else
4272         /* This message is probably going to be displayed in a 15
4273            character wide field, so put the hex value first.  */
4274         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4275
4276       return buff;
4277     }
4278 }
4279
4280 #define OPTION_DEBUG_DUMP       512
4281 #define OPTION_DYN_SYMS         513
4282 #define OPTION_DWARF_DEPTH      514
4283 #define OPTION_DWARF_START      515
4284 #define OPTION_DWARF_CHECK      516
4285
4286 static struct option options[] =
4287 {
4288   {"all",              no_argument, 0, 'a'},
4289   {"file-header",      no_argument, 0, 'h'},
4290   {"program-headers",  no_argument, 0, 'l'},
4291   {"headers",          no_argument, 0, 'e'},
4292   {"histogram",        no_argument, 0, 'I'},
4293   {"segments",         no_argument, 0, 'l'},
4294   {"sections",         no_argument, 0, 'S'},
4295   {"section-headers",  no_argument, 0, 'S'},
4296   {"section-groups",   no_argument, 0, 'g'},
4297   {"section-details",  no_argument, 0, 't'},
4298   {"full-section-name",no_argument, 0, 'N'},
4299   {"symbols",          no_argument, 0, 's'},
4300   {"syms",             no_argument, 0, 's'},
4301   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
4302   {"relocs",           no_argument, 0, 'r'},
4303   {"notes",            no_argument, 0, 'n'},
4304   {"dynamic",          no_argument, 0, 'd'},
4305   {"arch-specific",    no_argument, 0, 'A'},
4306   {"version-info",     no_argument, 0, 'V'},
4307   {"use-dynamic",      no_argument, 0, 'D'},
4308   {"unwind",           no_argument, 0, 'u'},
4309   {"archive-index",    no_argument, 0, 'c'},
4310   {"hex-dump",         required_argument, 0, 'x'},
4311   {"relocated-dump",   required_argument, 0, 'R'},
4312   {"string-dump",      required_argument, 0, 'p'},
4313   {"decompress",       no_argument, 0, 'z'},
4314 #ifdef SUPPORT_DISASSEMBLY
4315   {"instruction-dump", required_argument, 0, 'i'},
4316 #endif
4317   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
4318
4319   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
4320   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
4321   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
4322
4323   {"version",          no_argument, 0, 'v'},
4324   {"wide",             no_argument, 0, 'W'},
4325   {"help",             no_argument, 0, 'H'},
4326   {0,                  no_argument, 0, 0}
4327 };
4328
4329 static void
4330 usage (FILE * stream)
4331 {
4332   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4333   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4334   fprintf (stream, _(" Options are:\n\
4335   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4336   -h --file-header       Display the ELF file header\n\
4337   -l --program-headers   Display the program headers\n\
4338      --segments          An alias for --program-headers\n\
4339   -S --section-headers   Display the sections' header\n\
4340      --sections          An alias for --section-headers\n\
4341   -g --section-groups    Display the section groups\n\
4342   -t --section-details   Display the section details\n\
4343   -e --headers           Equivalent to: -h -l -S\n\
4344   -s --syms              Display the symbol table\n\
4345      --symbols           An alias for --syms\n\
4346   --dyn-syms             Display the dynamic symbol table\n\
4347   -n --notes             Display the core notes (if present)\n\
4348   -r --relocs            Display the relocations (if present)\n\
4349   -u --unwind            Display the unwind info (if present)\n\
4350   -d --dynamic           Display the dynamic section (if present)\n\
4351   -V --version-info      Display the version sections (if present)\n\
4352   -A --arch-specific     Display architecture specific information (if any)\n\
4353   -c --archive-index     Display the symbol/file index in an archive\n\
4354   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
4355   -x --hex-dump=<number|name>\n\
4356                          Dump the contents of section <number|name> as bytes\n\
4357   -p --string-dump=<number|name>\n\
4358                          Dump the contents of section <number|name> as strings\n\
4359   -R --relocated-dump=<number|name>\n\
4360                          Dump the contents of section <number|name> as relocated bytes\n\
4361   -z --decompress        Decompress section before dumping it\n\
4362   -w[lLiaprmfFsoRtUuTgAckK] or\n\
4363   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4364                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4365                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4366                =addr,=cu_index,=links,=follow-links]\n\
4367                          Display the contents of DWARF debug sections\n"));
4368   fprintf (stream, _("\
4369   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
4370   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
4371                          or deeper\n"));
4372 #ifdef SUPPORT_DISASSEMBLY
4373   fprintf (stream, _("\
4374   -i --instruction-dump=<number|name>\n\
4375                          Disassemble the contents of section <number|name>\n"));
4376 #endif
4377   fprintf (stream, _("\
4378   -I --histogram         Display histogram of bucket list lengths\n\
4379   -W --wide              Allow output width to exceed 80 characters\n\
4380   @<file>                Read options from <file>\n\
4381   -H --help              Display this information\n\
4382   -v --version           Display the version number of readelf\n"));
4383
4384   if (REPORT_BUGS_TO[0] && stream == stdout)
4385     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4386
4387   exit (stream == stdout ? 0 : 1);
4388 }
4389
4390 /* Record the fact that the user wants the contents of section number
4391    SECTION to be displayed using the method(s) encoded as flags bits
4392    in TYPE.  Note, TYPE can be zero if we are creating the array for
4393    the first time.  */
4394
4395 static void
4396 request_dump_bynumber (Filedata * filedata, unsigned int section, dump_type type)
4397 {
4398   if (section >= filedata->num_dump_sects)
4399     {
4400       dump_type * new_dump_sects;
4401
4402       new_dump_sects = (dump_type *) calloc (section + 1,
4403                                              sizeof (* new_dump_sects));
4404
4405       if (new_dump_sects == NULL)
4406         error (_("Out of memory allocating dump request table.\n"));
4407       else
4408         {
4409           if (filedata->dump_sects)
4410             {
4411               /* Copy current flag settings.  */
4412               memcpy (new_dump_sects, filedata->dump_sects,
4413                       filedata->num_dump_sects * sizeof (* new_dump_sects));
4414
4415               free (filedata->dump_sects);
4416             }
4417
4418           filedata->dump_sects = new_dump_sects;
4419           filedata->num_dump_sects = section + 1;
4420         }
4421     }
4422
4423   if (filedata->dump_sects)
4424     filedata->dump_sects[section] |= type;
4425 }
4426
4427 /* Request a dump by section name.  */
4428
4429 static void
4430 request_dump_byname (const char * section, dump_type type)
4431 {
4432   struct dump_list_entry * new_request;
4433
4434   new_request = (struct dump_list_entry *)
4435       malloc (sizeof (struct dump_list_entry));
4436   if (!new_request)
4437     error (_("Out of memory allocating dump request table.\n"));
4438
4439   new_request->name = strdup (section);
4440   if (!new_request->name)
4441     error (_("Out of memory allocating dump request table.\n"));
4442
4443   new_request->type = type;
4444
4445   new_request->next = dump_sects_byname;
4446   dump_sects_byname = new_request;
4447 }
4448
4449 static inline void
4450 request_dump (Filedata * filedata, dump_type type)
4451 {
4452   int section;
4453   char * cp;
4454
4455   do_dump++;
4456   section = strtoul (optarg, & cp, 0);
4457
4458   if (! *cp && section >= 0)
4459     request_dump_bynumber (filedata, section, type);
4460   else
4461     request_dump_byname (optarg, type);
4462 }
4463
4464 static void
4465 parse_args (Filedata * filedata, int argc, char ** argv)
4466 {
4467   int c;
4468
4469   if (argc < 2)
4470     usage (stderr);
4471
4472   while ((c = getopt_long
4473           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4474     {
4475       switch (c)
4476         {
4477         case 0:
4478           /* Long options.  */
4479           break;
4480         case 'H':
4481           usage (stdout);
4482           break;
4483
4484         case 'a':
4485           do_syms = TRUE;
4486           do_reloc = TRUE;
4487           do_unwind = TRUE;
4488           do_dynamic = TRUE;
4489           do_header = TRUE;
4490           do_sections = TRUE;
4491           do_section_groups = TRUE;
4492           do_segments = TRUE;
4493           do_version = TRUE;
4494           do_histogram = TRUE;
4495           do_arch = TRUE;
4496           do_notes = TRUE;
4497           break;
4498         case 'g':
4499           do_section_groups = TRUE;
4500           break;
4501         case 't':
4502         case 'N':
4503           do_sections = TRUE;
4504           do_section_details = TRUE;
4505           break;
4506         case 'e':
4507           do_header = TRUE;
4508           do_sections = TRUE;
4509           do_segments = TRUE;
4510           break;
4511         case 'A':
4512           do_arch = TRUE;
4513           break;
4514         case 'D':
4515           do_using_dynamic = TRUE;
4516           break;
4517         case 'r':
4518           do_reloc = TRUE;
4519           break;
4520         case 'u':
4521           do_unwind = TRUE;
4522           break;
4523         case 'h':
4524           do_header = TRUE;
4525           break;
4526         case 'l':
4527           do_segments = TRUE;
4528           break;
4529         case 's':
4530           do_syms = TRUE;
4531           break;
4532         case 'S':
4533           do_sections = TRUE;
4534           break;
4535         case 'd':
4536           do_dynamic = TRUE;
4537           break;
4538         case 'I':
4539           do_histogram = TRUE;
4540           break;
4541         case 'n':
4542           do_notes = TRUE;
4543           break;
4544         case 'c':
4545           do_archive_index = TRUE;
4546           break;
4547         case 'x':
4548           request_dump (filedata, HEX_DUMP);
4549           break;
4550         case 'p':
4551           request_dump (filedata, STRING_DUMP);
4552           break;
4553         case 'R':
4554           request_dump (filedata, RELOC_DUMP);
4555           break;
4556         case 'z':
4557           decompress_dumps = TRUE;
4558           break;
4559         case 'w':
4560           do_dump = TRUE;
4561           if (optarg == 0)
4562             {
4563               do_debugging = TRUE;
4564               dwarf_select_sections_all ();
4565             }
4566           else
4567             {
4568               do_debugging = FALSE;
4569               dwarf_select_sections_by_letters (optarg);
4570             }
4571           break;
4572         case OPTION_DEBUG_DUMP:
4573           do_dump = TRUE;
4574           if (optarg == 0)
4575             do_debugging = TRUE;
4576           else
4577             {
4578               do_debugging = FALSE;
4579               dwarf_select_sections_by_names (optarg);
4580             }
4581           break;
4582         case OPTION_DWARF_DEPTH:
4583           {
4584             char *cp;
4585
4586             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4587           }
4588           break;
4589         case OPTION_DWARF_START:
4590           {
4591             char *cp;
4592
4593             dwarf_start_die = strtoul (optarg, & cp, 0);
4594           }
4595           break;
4596         case OPTION_DWARF_CHECK:
4597           dwarf_check = TRUE;
4598           break;
4599         case OPTION_DYN_SYMS:
4600           do_dyn_syms = TRUE;
4601           break;
4602 #ifdef SUPPORT_DISASSEMBLY
4603         case 'i':
4604           request_dump (filedata, DISASS_DUMP);
4605           break;
4606 #endif
4607         case 'v':
4608           print_version (program_name);
4609           break;
4610         case 'V':
4611           do_version = TRUE;
4612           break;
4613         case 'W':
4614           do_wide = TRUE;
4615           break;
4616         default:
4617           /* xgettext:c-format */
4618           error (_("Invalid option '-%c'\n"), c);
4619           /* Fall through.  */
4620         case '?':
4621           usage (stderr);
4622         }
4623     }
4624
4625   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4626       && !do_segments && !do_header && !do_dump && !do_version
4627       && !do_histogram && !do_debugging && !do_arch && !do_notes
4628       && !do_section_groups && !do_archive_index
4629       && !do_dyn_syms)
4630     usage (stderr);
4631 }
4632
4633 static const char *
4634 get_elf_class (unsigned int elf_class)
4635 {
4636   static char buff[32];
4637
4638   switch (elf_class)
4639     {
4640     case ELFCLASSNONE: return _("none");
4641     case ELFCLASS32:   return "ELF32";
4642     case ELFCLASS64:   return "ELF64";
4643     default:
4644       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4645       return buff;
4646     }
4647 }
4648
4649 static const char *
4650 get_data_encoding (unsigned int encoding)
4651 {
4652   static char buff[32];
4653
4654   switch (encoding)
4655     {
4656     case ELFDATANONE: return _("none");
4657     case ELFDATA2LSB: return _("2's complement, little endian");
4658     case ELFDATA2MSB: return _("2's complement, big endian");
4659     default:
4660       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4661       return buff;
4662     }
4663 }
4664
4665 /* Decode the data held in 'filedata->file_header'.  */
4666
4667 static bfd_boolean
4668 process_file_header (Filedata * filedata)
4669 {
4670   Elf_Internal_Ehdr * header = & filedata->file_header;
4671
4672   if (   header->e_ident[EI_MAG0] != ELFMAG0
4673       || header->e_ident[EI_MAG1] != ELFMAG1
4674       || header->e_ident[EI_MAG2] != ELFMAG2
4675       || header->e_ident[EI_MAG3] != ELFMAG3)
4676     {
4677       error
4678         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4679       return FALSE;
4680     }
4681
4682   init_dwarf_regnames (header->e_machine);
4683
4684   if (do_header)
4685     {
4686       unsigned i;
4687
4688       printf (_("ELF Header:\n"));
4689       printf (_("  Magic:   "));
4690       for (i = 0; i < EI_NIDENT; i++)
4691         printf ("%2.2x ", header->e_ident[i]);
4692       printf ("\n");
4693       printf (_("  Class:                             %s\n"),
4694               get_elf_class (header->e_ident[EI_CLASS]));
4695       printf (_("  Data:                              %s\n"),
4696               get_data_encoding (header->e_ident[EI_DATA]));
4697       printf (_("  Version:                           %d %s\n"),
4698               header->e_ident[EI_VERSION],
4699               (header->e_ident[EI_VERSION] == EV_CURRENT
4700                ? "(current)"
4701                : (header->e_ident[EI_VERSION] != EV_NONE
4702                   ? _("<unknown: %lx>")
4703                   : "")));
4704       printf (_("  OS/ABI:                            %s\n"),
4705               get_osabi_name (filedata, header->e_ident[EI_OSABI]));
4706       printf (_("  ABI Version:                       %d\n"),
4707               header->e_ident[EI_ABIVERSION]);
4708       printf (_("  Type:                              %s\n"),
4709               get_file_type (header->e_type));
4710       printf (_("  Machine:                           %s\n"),
4711               get_machine_name (header->e_machine));
4712       printf (_("  Version:                           0x%lx\n"),
4713               (unsigned long) header->e_version);
4714
4715       printf (_("  Entry point address:               "));
4716       print_vma ((bfd_vma) header->e_entry, PREFIX_HEX);
4717       printf (_("\n  Start of program headers:          "));
4718       print_vma ((bfd_vma) header->e_phoff, DEC);
4719       printf (_(" (bytes into file)\n  Start of section headers:          "));
4720       print_vma ((bfd_vma) header->e_shoff, DEC);
4721       printf (_(" (bytes into file)\n"));
4722
4723       printf (_("  Flags:                             0x%lx%s\n"),
4724               (unsigned long) header->e_flags,
4725               get_machine_flags (filedata, header->e_flags, header->e_machine));
4726       printf (_("  Size of this header:               %ld (bytes)\n"),
4727               (long) header->e_ehsize);
4728       printf (_("  Size of program headers:           %ld (bytes)\n"),
4729               (long) header->e_phentsize);
4730       printf (_("  Number of program headers:         %ld"),
4731               (long) header->e_phnum);
4732       if (filedata->section_headers != NULL
4733           && header->e_phnum == PN_XNUM
4734           && filedata->section_headers[0].sh_info != 0)
4735         printf (" (%ld)", (long) filedata->section_headers[0].sh_info);
4736       putc ('\n', stdout);
4737       printf (_("  Size of section headers:           %ld (bytes)\n"),
4738               (long) header->e_shentsize);
4739       printf (_("  Number of section headers:         %ld"),
4740               (long) header->e_shnum);
4741       if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
4742         printf (" (%ld)", (long) filedata->section_headers[0].sh_size);
4743       putc ('\n', stdout);
4744       printf (_("  Section header string table index: %ld"),
4745               (long) header->e_shstrndx);
4746       if (filedata->section_headers != NULL
4747           && header->e_shstrndx == (SHN_XINDEX & 0xffff))
4748         printf (" (%u)", filedata->section_headers[0].sh_link);
4749       else if (header->e_shstrndx != SHN_UNDEF
4750                && header->e_shstrndx >= header->e_shnum)
4751         printf (_(" <corrupt: out of range>"));
4752       putc ('\n', stdout);
4753     }
4754
4755   if (filedata->section_headers != NULL)
4756     {
4757       if (header->e_phnum == PN_XNUM
4758           && filedata->section_headers[0].sh_info != 0)
4759         header->e_phnum = filedata->section_headers[0].sh_info;
4760       if (header->e_shnum == SHN_UNDEF)
4761         header->e_shnum = filedata->section_headers[0].sh_size;
4762       if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
4763         header->e_shstrndx = filedata->section_headers[0].sh_link;
4764       else if (header->e_shstrndx >= header->e_shnum)
4765         header->e_shstrndx = SHN_UNDEF;
4766       free (filedata->section_headers);
4767       filedata->section_headers = NULL;
4768     }
4769
4770   return TRUE;
4771 }
4772
4773 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4774    Returns TRUE upon success, FALSE otherwise.  Loads 32-bit headers.  */
4775
4776 static bfd_boolean
4777 get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4778 {
4779   Elf32_External_Phdr * phdrs;
4780   Elf32_External_Phdr * external;
4781   Elf_Internal_Phdr *   internal;
4782   unsigned int i;
4783   unsigned int size = filedata->file_header.e_phentsize;
4784   unsigned int num  = filedata->file_header.e_phnum;
4785
4786   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4787   if (size == 0 || num == 0)
4788     return FALSE;
4789   if (size < sizeof * phdrs)
4790     {
4791       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4792       return FALSE;
4793     }
4794   if (size > sizeof * phdrs)
4795     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4796
4797   phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4798                                             size, num, _("program headers"));
4799   if (phdrs == NULL)
4800     return FALSE;
4801
4802   for (i = 0, internal = pheaders, external = phdrs;
4803        i < filedata->file_header.e_phnum;
4804        i++, internal++, external++)
4805     {
4806       internal->p_type   = BYTE_GET (external->p_type);
4807       internal->p_offset = BYTE_GET (external->p_offset);
4808       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4809       internal->p_paddr  = BYTE_GET (external->p_paddr);
4810       internal->p_filesz = BYTE_GET (external->p_filesz);
4811       internal->p_memsz  = BYTE_GET (external->p_memsz);
4812       internal->p_flags  = BYTE_GET (external->p_flags);
4813       internal->p_align  = BYTE_GET (external->p_align);
4814     }
4815
4816   free (phdrs);
4817   return TRUE;
4818 }
4819
4820 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4821    Returns TRUE upon success, FALSE otherwise.  Loads 64-bit headers.  */
4822
4823 static bfd_boolean
4824 get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4825 {
4826   Elf64_External_Phdr * phdrs;
4827   Elf64_External_Phdr * external;
4828   Elf_Internal_Phdr *   internal;
4829   unsigned int i;
4830   unsigned int size = filedata->file_header.e_phentsize;
4831   unsigned int num  = filedata->file_header.e_phnum;
4832
4833   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4834   if (size == 0 || num == 0)
4835     return FALSE;
4836   if (size < sizeof * phdrs)
4837     {
4838       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4839       return FALSE;
4840     }
4841   if (size > sizeof * phdrs)
4842     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4843
4844   phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4845                                             size, num, _("program headers"));
4846   if (!phdrs)
4847     return FALSE;
4848
4849   for (i = 0, internal = pheaders, external = phdrs;
4850        i < filedata->file_header.e_phnum;
4851        i++, internal++, external++)
4852     {
4853       internal->p_type   = BYTE_GET (external->p_type);
4854       internal->p_flags  = BYTE_GET (external->p_flags);
4855       internal->p_offset = BYTE_GET (external->p_offset);
4856       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4857       internal->p_paddr  = BYTE_GET (external->p_paddr);
4858       internal->p_filesz = BYTE_GET (external->p_filesz);
4859       internal->p_memsz  = BYTE_GET (external->p_memsz);
4860       internal->p_align  = BYTE_GET (external->p_align);
4861     }
4862
4863   free (phdrs);
4864   return TRUE;
4865 }
4866
4867 /* Returns TRUE if the program headers were read into `program_headers'.  */
4868
4869 static bfd_boolean
4870 get_program_headers (Filedata * filedata)
4871 {
4872   Elf_Internal_Phdr * phdrs;
4873
4874   /* Check cache of prior read.  */
4875   if (filedata->program_headers != NULL)
4876     return TRUE;
4877
4878   /* Be kind to memory checkers by looking for
4879      e_phnum values which we know must be invalid.  */
4880   if (filedata->file_header.e_phnum
4881       * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
4882       >= filedata->file_size)
4883     {
4884       error (_("Too many program headers - %#x - the file is not that big\n"),
4885              filedata->file_header.e_phnum);
4886       return FALSE;
4887     }
4888
4889   phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
4890                                          sizeof (Elf_Internal_Phdr));
4891   if (phdrs == NULL)
4892     {
4893       error (_("Out of memory reading %u program headers\n"),
4894              filedata->file_header.e_phnum);
4895       return FALSE;
4896     }
4897
4898   if (is_32bit_elf
4899       ? get_32bit_program_headers (filedata, phdrs)
4900       : get_64bit_program_headers (filedata, phdrs))
4901     {
4902       filedata->program_headers = phdrs;
4903       return TRUE;
4904     }
4905
4906   free (phdrs);
4907   return FALSE;
4908 }
4909
4910 /* Returns TRUE if the program headers were loaded.  */
4911
4912 static bfd_boolean
4913 process_program_headers (Filedata * filedata)
4914 {
4915   Elf_Internal_Phdr * segment;
4916   unsigned int i;
4917   Elf_Internal_Phdr * previous_load = NULL;
4918
4919   if (filedata->file_header.e_phnum == 0)
4920     {
4921       /* PR binutils/12467.  */
4922       if (filedata->file_header.e_phoff != 0)
4923         {
4924           warn (_("possibly corrupt ELF header - it has a non-zero program"
4925                   " header offset, but no program headers\n"));
4926           return FALSE;
4927         }
4928       else if (do_segments)
4929         printf (_("\nThere are no program headers in this file.\n"));
4930       return TRUE;
4931     }
4932
4933   if (do_segments && !do_header)
4934     {
4935       printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
4936       printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
4937       printf (ngettext ("There is %d program header, starting at offset %s\n",
4938                         "There are %d program headers, starting at offset %s\n",
4939                         filedata->file_header.e_phnum),
4940               filedata->file_header.e_phnum,
4941               bfd_vmatoa ("u", filedata->file_header.e_phoff));
4942     }
4943
4944   if (! get_program_headers (filedata))
4945     return TRUE;
4946
4947   if (do_segments)
4948     {
4949       if (filedata->file_header.e_phnum > 1)
4950         printf (_("\nProgram Headers:\n"));
4951       else
4952         printf (_("\nProgram Headers:\n"));
4953
4954       if (is_32bit_elf)
4955         printf
4956           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
4957       else if (do_wide)
4958         printf
4959           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
4960       else
4961         {
4962           printf
4963             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
4964           printf
4965             (_("                 FileSiz            MemSiz              Flags  Align\n"));
4966         }
4967     }
4968
4969   dynamic_addr = 0;
4970   dynamic_size = 0;
4971
4972   for (i = 0, segment = filedata->program_headers;
4973        i < filedata->file_header.e_phnum;
4974        i++, segment++)
4975     {
4976       if (do_segments)
4977         {
4978           printf ("  %-14.14s ", get_segment_type (filedata, segment->p_type));
4979
4980           if (is_32bit_elf)
4981             {
4982               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4983               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4984               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4985               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4986               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4987               printf ("%c%c%c ",
4988                       (segment->p_flags & PF_R ? 'R' : ' '),
4989                       (segment->p_flags & PF_W ? 'W' : ' '),
4990                       (segment->p_flags & PF_X ? 'E' : ' '));
4991               printf ("%#lx", (unsigned long) segment->p_align);
4992             }
4993           else if (do_wide)
4994             {
4995               if ((unsigned long) segment->p_offset == segment->p_offset)
4996                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4997               else
4998                 {
4999                   print_vma (segment->p_offset, FULL_HEX);
5000                   putchar (' ');
5001                 }
5002
5003               print_vma (segment->p_vaddr, FULL_HEX);
5004               putchar (' ');
5005               print_vma (segment->p_paddr, FULL_HEX);
5006               putchar (' ');
5007
5008               if ((unsigned long) segment->p_filesz == segment->p_filesz)
5009                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
5010               else
5011                 {
5012                   print_vma (segment->p_filesz, FULL_HEX);
5013                   putchar (' ');
5014                 }
5015
5016               if ((unsigned long) segment->p_memsz == segment->p_memsz)
5017                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5018               else
5019                 {
5020                   print_vma (segment->p_memsz, FULL_HEX);
5021                 }
5022
5023               printf (" %c%c%c ",
5024                       (segment->p_flags & PF_R ? 'R' : ' '),
5025                       (segment->p_flags & PF_W ? 'W' : ' '),
5026                       (segment->p_flags & PF_X ? 'E' : ' '));
5027
5028               if ((unsigned long) segment->p_align == segment->p_align)
5029                 printf ("%#lx", (unsigned long) segment->p_align);
5030               else
5031                 {
5032                   print_vma (segment->p_align, PREFIX_HEX);
5033                 }
5034             }
5035           else
5036             {
5037               print_vma (segment->p_offset, FULL_HEX);
5038               putchar (' ');
5039               print_vma (segment->p_vaddr, FULL_HEX);
5040               putchar (' ');
5041               print_vma (segment->p_paddr, FULL_HEX);
5042               printf ("\n                 ");
5043               print_vma (segment->p_filesz, FULL_HEX);
5044               putchar (' ');
5045               print_vma (segment->p_memsz, FULL_HEX);
5046               printf ("  %c%c%c    ",
5047                       (segment->p_flags & PF_R ? 'R' : ' '),
5048                       (segment->p_flags & PF_W ? 'W' : ' '),
5049                       (segment->p_flags & PF_X ? 'E' : ' '));
5050               print_vma (segment->p_align, PREFIX_HEX);
5051             }
5052
5053           putc ('\n', stdout);
5054         }
5055
5056       switch (segment->p_type)
5057         {
5058         case PT_LOAD:
5059 #if 0 /* Do not warn about out of order PT_LOAD segments.  Although officially
5060          required by the ELF standard, several programs, including the Linux
5061          kernel, make use of non-ordered segments.  */
5062           if (previous_load
5063               && previous_load->p_vaddr > segment->p_vaddr)
5064             error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5065 #endif
5066           if (segment->p_memsz < segment->p_filesz)
5067             error (_("the segment's file size is larger than its memory size\n"));
5068           previous_load = segment;
5069           break;
5070
5071         case PT_PHDR:
5072           /* PR 20815 - Verify that the program header is loaded into memory.  */
5073           if (i > 0 && previous_load != NULL)
5074             error (_("the PHDR segment must occur before any LOAD segment\n"));
5075           if (filedata->file_header.e_machine != EM_PARISC)
5076             {
5077               unsigned int j;
5078
5079               for (j = 1; j < filedata->file_header.e_phnum; j++)
5080                 if (filedata->program_headers[j].p_vaddr <= segment->p_vaddr
5081                     && (filedata->program_headers[j].p_vaddr
5082                         + filedata->program_headers[j].p_memsz)
5083                     >= (segment->p_vaddr + segment->p_filesz))
5084                   break;
5085               if (j == filedata->file_header.e_phnum)
5086                 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5087             }
5088           break;
5089
5090         case PT_DYNAMIC:
5091           if (dynamic_addr)
5092             error (_("more than one dynamic segment\n"));
5093
5094           /* By default, assume that the .dynamic section is the first
5095              section in the DYNAMIC segment.  */
5096           dynamic_addr = segment->p_offset;
5097           dynamic_size = segment->p_filesz;
5098
5099           /* Try to locate the .dynamic section. If there is
5100              a section header table, we can easily locate it.  */
5101           if (filedata->section_headers != NULL)
5102             {
5103               Elf_Internal_Shdr * sec;
5104
5105               sec = find_section (filedata, ".dynamic");
5106               if (sec == NULL || sec->sh_size == 0)
5107                 {
5108                   /* A corresponding .dynamic section is expected, but on
5109                      IA-64/OpenVMS it is OK for it to be missing.  */
5110                   if (!is_ia64_vms (filedata))
5111                     error (_("no .dynamic section in the dynamic segment\n"));
5112                   break;
5113                 }
5114
5115               if (sec->sh_type == SHT_NOBITS)
5116                 {
5117                   dynamic_size = 0;
5118                   break;
5119                 }
5120
5121               dynamic_addr = sec->sh_offset;
5122               dynamic_size = sec->sh_size;
5123
5124               if (dynamic_addr < segment->p_offset
5125                   || dynamic_addr > segment->p_offset + segment->p_filesz)
5126                 warn (_("the .dynamic section is not contained"
5127                         " within the dynamic segment\n"));
5128               else if (dynamic_addr > segment->p_offset)
5129                 warn (_("the .dynamic section is not the first section"
5130                         " in the dynamic segment.\n"));
5131             }
5132
5133           /* PR binutils/17512: Avoid corrupt dynamic section info in the
5134              segment.  Check this after matching against the section headers
5135              so we don't warn on debuginfo file (which have NOBITS .dynamic
5136              sections).  */
5137           if (dynamic_addr + dynamic_size >= filedata->file_size)
5138             {
5139               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5140               dynamic_addr = dynamic_size = 0;
5141             }
5142           break;
5143
5144         case PT_INTERP:
5145           if (fseek (filedata->handle, archive_file_offset + (long) segment->p_offset,
5146                      SEEK_SET))
5147             error (_("Unable to find program interpreter name\n"));
5148           else
5149             {
5150               char fmt [32];
5151               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5152
5153               if (ret >= (int) sizeof (fmt) || ret < 0)
5154                 error (_("Internal error: failed to create format string to display program interpreter\n"));
5155
5156               program_interpreter[0] = 0;
5157               if (fscanf (filedata->handle, fmt, program_interpreter) <= 0)
5158                 error (_("Unable to read program interpreter name\n"));
5159
5160               if (do_segments)
5161                 printf (_("      [Requesting program interpreter: %s]\n"),
5162                     program_interpreter);
5163             }
5164           break;
5165         }
5166     }
5167
5168   if (do_segments
5169       && filedata->section_headers != NULL
5170       && filedata->string_table != NULL)
5171     {
5172       printf (_("\n Section to Segment mapping:\n"));
5173       printf (_("  Segment Sections...\n"));
5174
5175       for (i = 0; i < filedata->file_header.e_phnum; i++)
5176         {
5177           unsigned int j;
5178           Elf_Internal_Shdr * section;
5179
5180           segment = filedata->program_headers + i;
5181           section = filedata->section_headers + 1;
5182
5183           printf ("   %2.2d     ", i);
5184
5185           for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
5186             {
5187               if (!ELF_TBSS_SPECIAL (section, segment)
5188                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5189                 printf ("%s ", printable_section_name (filedata, section));
5190             }
5191
5192           putc ('\n',stdout);
5193         }
5194     }
5195
5196   return TRUE;
5197 }
5198
5199
5200 /* Find the file offset corresponding to VMA by using the program headers.  */
5201
5202 static long
5203 offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
5204 {
5205   Elf_Internal_Phdr * seg;
5206
5207   if (! get_program_headers (filedata))
5208     {
5209       warn (_("Cannot interpret virtual addresses without program headers.\n"));
5210       return (long) vma;
5211     }
5212
5213   for (seg = filedata->program_headers;
5214        seg < filedata->program_headers + filedata->file_header.e_phnum;
5215        ++seg)
5216     {
5217       if (seg->p_type != PT_LOAD)
5218         continue;
5219
5220       if (vma >= (seg->p_vaddr & -seg->p_align)
5221           && vma + size <= seg->p_vaddr + seg->p_filesz)
5222         return vma - seg->p_vaddr + seg->p_offset;
5223     }
5224
5225   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5226         (unsigned long) vma);
5227   return (long) vma;
5228 }
5229
5230
5231 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5232    If PROBE is true, this is just a probe and we do not generate any error
5233    messages if the load fails.  */
5234
5235 static bfd_boolean
5236 get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
5237 {
5238   Elf32_External_Shdr * shdrs;
5239   Elf_Internal_Shdr *   internal;
5240   unsigned int          i;
5241   unsigned int          size = filedata->file_header.e_shentsize;
5242   unsigned int          num = probe ? 1 : filedata->file_header.e_shnum;
5243
5244   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5245   if (size == 0 || num == 0)
5246     return FALSE;
5247   if (size < sizeof * shdrs)
5248     {
5249       if (! probe)
5250         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5251       return FALSE;
5252     }
5253   if (!probe && size > sizeof * shdrs)
5254     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5255
5256   shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
5257                                             size, num,
5258                                             probe ? NULL : _("section headers"));
5259   if (shdrs == NULL)
5260     return FALSE;
5261
5262   free (filedata->section_headers);
5263   filedata->section_headers = (Elf_Internal_Shdr *)
5264     cmalloc (num, sizeof (Elf_Internal_Shdr));
5265   if (filedata->section_headers == NULL)
5266     {
5267       if (!probe)
5268         error (_("Out of memory reading %u section headers\n"), num);
5269       return FALSE;
5270     }
5271
5272   for (i = 0, internal = filedata->section_headers;
5273        i < num;
5274        i++, internal++)
5275     {
5276       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5277       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5278       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5279       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5280       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5281       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5282       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5283       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5284       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5285       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5286       if (!probe && internal->sh_link > num)
5287         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5288       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5289         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5290     }
5291
5292   free (shdrs);
5293   return TRUE;
5294 }
5295
5296 /* Like get_32bit_section_headers, except that it fetches 64-bit headers.  */
5297
5298 static bfd_boolean
5299 get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
5300 {
5301   Elf64_External_Shdr *  shdrs;
5302   Elf_Internal_Shdr *    internal;
5303   unsigned int           i;
5304   unsigned int           size = filedata->file_header.e_shentsize;
5305   unsigned int           num = probe ? 1 : filedata->file_header.e_shnum;
5306
5307   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5308   if (size == 0 || num == 0)
5309     return FALSE;
5310
5311   if (size < sizeof * shdrs)
5312     {
5313       if (! probe)
5314         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5315       return FALSE;
5316     }
5317
5318   if (! probe && size > sizeof * shdrs)
5319     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5320
5321   shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
5322                                             filedata->file_header.e_shoff,
5323                                             size, num,
5324                                             probe ? NULL : _("section headers"));
5325   if (shdrs == NULL)
5326     return FALSE;
5327
5328   free (filedata->section_headers);
5329   filedata->section_headers = (Elf_Internal_Shdr *)
5330     cmalloc (num, sizeof (Elf_Internal_Shdr));
5331   if (filedata->section_headers == NULL)
5332     {
5333       if (! probe)
5334         error (_("Out of memory reading %u section headers\n"), num);
5335       return FALSE;
5336     }
5337
5338   for (i = 0, internal = filedata->section_headers;
5339        i < num;
5340        i++, internal++)
5341     {
5342       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5343       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5344       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5345       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5346       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5347       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5348       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5349       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5350       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5351       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5352       if (!probe && internal->sh_link > num)
5353         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5354       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5355         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5356     }
5357
5358   free (shdrs);
5359   return TRUE;
5360 }
5361
5362 static Elf_Internal_Sym *
5363 get_32bit_elf_symbols (Filedata *           filedata,
5364                        Elf_Internal_Shdr *  section,
5365                        unsigned long *      num_syms_return)
5366 {
5367   unsigned long number = 0;
5368   Elf32_External_Sym * esyms = NULL;
5369   Elf_External_Sym_Shndx * shndx = NULL;
5370   Elf_Internal_Sym * isyms = NULL;
5371   Elf_Internal_Sym * psym;
5372   unsigned int j;
5373
5374   if (section->sh_size == 0)
5375     {
5376       if (num_syms_return != NULL)
5377         * num_syms_return = 0;
5378       return NULL;
5379     }
5380
5381   /* Run some sanity checks first.  */
5382   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5383     {
5384       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5385              printable_section_name (filedata, section),
5386              (unsigned long) section->sh_entsize);
5387       goto exit_point;
5388     }
5389
5390   if (section->sh_size > filedata->file_size)
5391     {
5392       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5393              printable_section_name (filedata, section),
5394              (unsigned long) section->sh_size);
5395       goto exit_point;
5396     }
5397
5398   number = section->sh_size / section->sh_entsize;
5399
5400   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5401     {
5402       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5403              (unsigned long) section->sh_size,
5404              printable_section_name (filedata, section),
5405              (unsigned long) section->sh_entsize);
5406       goto exit_point;
5407     }
5408
5409   esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5410                                            section->sh_size, _("symbols"));
5411   if (esyms == NULL)
5412     goto exit_point;
5413
5414   {
5415     elf_section_list * entry;
5416
5417     shndx = NULL;
5418     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5419       if (entry->hdr->sh_link == (unsigned long) (section - filedata->section_headers))
5420         {
5421           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5422                                                        entry->hdr->sh_offset,
5423                                                        1, entry->hdr->sh_size,
5424                                                        _("symbol table section indicies"));
5425           if (shndx == NULL)
5426             goto exit_point;
5427           /* PR17531: file: heap-buffer-overflow */
5428           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5429             {
5430               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5431                      printable_section_name (filedata, entry->hdr),
5432                      (unsigned long) entry->hdr->sh_size,
5433                      (unsigned long) section->sh_size);
5434               goto exit_point;
5435             }
5436         }
5437   }
5438
5439   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5440
5441   if (isyms == NULL)
5442     {
5443       error (_("Out of memory reading %lu symbols\n"),
5444              (unsigned long) number);
5445       goto exit_point;
5446     }
5447
5448   for (j = 0, psym = isyms; j < number; j++, psym++)
5449     {
5450       psym->st_name  = BYTE_GET (esyms[j].st_name);
5451       psym->st_value = BYTE_GET (esyms[j].st_value);
5452       psym->st_size  = BYTE_GET (esyms[j].st_size);
5453       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5454       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5455         psym->st_shndx
5456           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5457       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5458         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5459       psym->st_info  = BYTE_GET (esyms[j].st_info);
5460       psym->st_other = BYTE_GET (esyms[j].st_other);
5461     }
5462
5463  exit_point:
5464   if (shndx != NULL)
5465     free (shndx);
5466   if (esyms != NULL)
5467     free (esyms);
5468
5469   if (num_syms_return != NULL)
5470     * num_syms_return = isyms == NULL ? 0 : number;
5471
5472   return isyms;
5473 }
5474
5475 static Elf_Internal_Sym *
5476 get_64bit_elf_symbols (Filedata *           filedata,
5477                        Elf_Internal_Shdr *  section,
5478                        unsigned long *      num_syms_return)
5479 {
5480   unsigned long number = 0;
5481   Elf64_External_Sym * esyms = NULL;
5482   Elf_External_Sym_Shndx * shndx = NULL;
5483   Elf_Internal_Sym * isyms = NULL;
5484   Elf_Internal_Sym * psym;
5485   unsigned int j;
5486
5487   if (section->sh_size == 0)
5488     {
5489       if (num_syms_return != NULL)
5490         * num_syms_return = 0;
5491       return NULL;
5492     }
5493
5494   /* Run some sanity checks first.  */
5495   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5496     {
5497       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5498              printable_section_name (filedata, section),
5499              (unsigned long) section->sh_entsize);
5500       goto exit_point;
5501     }
5502
5503   if (section->sh_size > filedata->file_size)
5504     {
5505       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5506              printable_section_name (filedata, section),
5507              (unsigned long) section->sh_size);
5508       goto exit_point;
5509     }
5510
5511   number = section->sh_size / section->sh_entsize;
5512
5513   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5514     {
5515       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5516              (unsigned long) section->sh_size,
5517              printable_section_name (filedata, section),
5518              (unsigned long) section->sh_entsize);
5519       goto exit_point;
5520     }
5521
5522   esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5523                                            section->sh_size, _("symbols"));
5524   if (!esyms)
5525     goto exit_point;
5526
5527   {
5528     elf_section_list * entry;
5529
5530     shndx = NULL;
5531     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5532       if (entry->hdr->sh_link == (unsigned long) (section - filedata->section_headers))
5533         {
5534           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5535                                                        entry->hdr->sh_offset,
5536                                                        1, entry->hdr->sh_size,
5537                                                        _("symbol table section indicies"));
5538           if (shndx == NULL)
5539             goto exit_point;
5540           /* PR17531: file: heap-buffer-overflow */
5541           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5542             {
5543               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5544                      printable_section_name (filedata, entry->hdr),
5545                      (unsigned long) entry->hdr->sh_size,
5546                      (unsigned long) section->sh_size);
5547               goto exit_point;
5548             }
5549         }
5550   }
5551
5552   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5553
5554   if (isyms == NULL)
5555     {
5556       error (_("Out of memory reading %lu symbols\n"),
5557              (unsigned long) number);
5558       goto exit_point;
5559     }
5560
5561   for (j = 0, psym = isyms; j < number; j++, psym++)
5562     {
5563       psym->st_name  = BYTE_GET (esyms[j].st_name);
5564       psym->st_info  = BYTE_GET (esyms[j].st_info);
5565       psym->st_other = BYTE_GET (esyms[j].st_other);
5566       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5567
5568       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5569         psym->st_shndx
5570           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5571       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5572         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5573
5574       psym->st_value = BYTE_GET (esyms[j].st_value);
5575       psym->st_size  = BYTE_GET (esyms[j].st_size);
5576     }
5577
5578  exit_point:
5579   if (shndx != NULL)
5580     free (shndx);
5581   if (esyms != NULL)
5582     free (esyms);
5583
5584   if (num_syms_return != NULL)
5585     * num_syms_return = isyms == NULL ? 0 : number;
5586
5587   return isyms;
5588 }
5589
5590 static const char *
5591 get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
5592 {
5593   static char buff[1024];
5594   char * p = buff;
5595   unsigned int field_size = is_32bit_elf ? 8 : 16;
5596   signed int sindex;
5597   unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5598   bfd_vma os_flags = 0;
5599   bfd_vma proc_flags = 0;
5600   bfd_vma unknown_flags = 0;
5601   static const struct
5602     {
5603       const char * str;
5604       unsigned int len;
5605     }
5606   flags [] =
5607     {
5608       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5609       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5610       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5611       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5612       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5613       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5614       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5615       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5616       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5617       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5618       /* IA-64 specific.  */
5619       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5620       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5621       /* IA-64 OpenVMS specific.  */
5622       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5623       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5624       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5625       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5626       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5627       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5628       /* Generic.  */
5629       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5630       /* SPARC specific.  */
5631       /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5632       /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5633       /* ARM specific.  */
5634       /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5635       /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5636       /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5637       /* GNU specific.  */
5638       /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5639       /* VLE specific.  */
5640       /* 25 */ { STRING_COMMA_LEN ("VLE") },
5641     };
5642
5643   if (do_section_details)
5644     {
5645       sprintf (buff, "[%*.*lx]: ",
5646                field_size, field_size, (unsigned long) sh_flags);
5647       p += field_size + 4;
5648     }
5649
5650   while (sh_flags)
5651     {
5652       bfd_vma flag;
5653
5654       flag = sh_flags & - sh_flags;
5655       sh_flags &= ~ flag;
5656
5657       if (do_section_details)
5658         {
5659           switch (flag)
5660             {
5661             case SHF_WRITE:             sindex = 0; break;
5662             case SHF_ALLOC:             sindex = 1; break;
5663             case SHF_EXECINSTR:         sindex = 2; break;
5664             case SHF_MERGE:             sindex = 3; break;
5665             case SHF_STRINGS:           sindex = 4; break;
5666             case SHF_INFO_LINK:         sindex = 5; break;
5667             case SHF_LINK_ORDER:        sindex = 6; break;
5668             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5669             case SHF_GROUP:             sindex = 8; break;
5670             case SHF_TLS:               sindex = 9; break;
5671             case SHF_EXCLUDE:           sindex = 18; break;
5672             case SHF_COMPRESSED:        sindex = 20; break;
5673             case SHF_GNU_MBIND:         sindex = 24; break;
5674
5675             default:
5676               sindex = -1;
5677               switch (filedata->file_header.e_machine)
5678                 {
5679                 case EM_IA_64:
5680                   if (flag == SHF_IA_64_SHORT)
5681                     sindex = 10;
5682                   else if (flag == SHF_IA_64_NORECOV)
5683                     sindex = 11;
5684 #ifdef BFD64
5685                   else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5686                     switch (flag)
5687                       {
5688                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5689                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5690                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5691                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5692                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5693                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5694                       default:                        break;
5695                       }
5696 #endif
5697                   break;
5698
5699                 case EM_386:
5700                 case EM_IAMCU:
5701                 case EM_X86_64:
5702                 case EM_L1OM:
5703                 case EM_K1OM:
5704                 case EM_OLD_SPARCV9:
5705                 case EM_SPARC32PLUS:
5706                 case EM_SPARCV9:
5707                 case EM_SPARC:
5708                   if (flag == SHF_ORDERED)
5709                     sindex = 19;
5710                   break;
5711
5712                 case EM_ARM:
5713                   switch (flag)
5714                     {
5715                     case SHF_ENTRYSECT: sindex = 21; break;
5716                     case SHF_ARM_PURECODE: sindex = 22; break;
5717                     case SHF_COMDEF: sindex = 23; break;
5718                     default: break;
5719                     }
5720                   break;
5721                 case EM_PPC:
5722                   if (flag == SHF_PPC_VLE)
5723                     sindex = 25;
5724                   break;
5725
5726                 default:
5727                   break;
5728                 }
5729             }
5730
5731           if (sindex != -1)
5732             {
5733               if (p != buff + field_size + 4)
5734                 {
5735                   if (size < (10 + 2))
5736                     {
5737                       warn (_("Internal error: not enough buffer room for section flag info"));
5738                       return _("<unknown>");
5739                     }
5740                   size -= 2;
5741                   *p++ = ',';
5742                   *p++ = ' ';
5743                 }
5744
5745               size -= flags [sindex].len;
5746               p = stpcpy (p, flags [sindex].str);
5747             }
5748           else if (flag & SHF_MASKOS)
5749             os_flags |= flag;
5750           else if (flag & SHF_MASKPROC)
5751             proc_flags |= flag;
5752           else
5753             unknown_flags |= flag;
5754         }
5755       else
5756         {
5757           switch (flag)
5758             {
5759             case SHF_WRITE:             *p = 'W'; break;
5760             case SHF_ALLOC:             *p = 'A'; break;
5761             case SHF_EXECINSTR:         *p = 'X'; break;
5762             case SHF_MERGE:             *p = 'M'; break;
5763             case SHF_STRINGS:           *p = 'S'; break;
5764             case SHF_INFO_LINK:         *p = 'I'; break;
5765             case SHF_LINK_ORDER:        *p = 'L'; break;
5766             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5767             case SHF_GROUP:             *p = 'G'; break;
5768             case SHF_TLS:               *p = 'T'; break;
5769             case SHF_EXCLUDE:           *p = 'E'; break;
5770             case SHF_COMPRESSED:        *p = 'C'; break;
5771             case SHF_GNU_MBIND:         *p = 'D'; break;
5772
5773             default:
5774               if ((filedata->file_header.e_machine == EM_X86_64
5775                    || filedata->file_header.e_machine == EM_L1OM
5776                    || filedata->file_header.e_machine == EM_K1OM)
5777                   && flag == SHF_X86_64_LARGE)
5778                 *p = 'l';
5779               else if (filedata->file_header.e_machine == EM_ARM
5780                        && flag == SHF_ARM_PURECODE)
5781                   *p = 'y';
5782               else if (filedata->file_header.e_machine == EM_PPC
5783                        && flag == SHF_PPC_VLE)
5784                   *p = 'v';
5785               else if (flag & SHF_MASKOS)
5786                 {
5787                   *p = 'o';
5788                   sh_flags &= ~ SHF_MASKOS;
5789                 }
5790               else if (flag & SHF_MASKPROC)
5791                 {
5792                   *p = 'p';
5793                   sh_flags &= ~ SHF_MASKPROC;
5794                 }
5795               else
5796                 *p = 'x';
5797               break;
5798             }
5799           p++;
5800         }
5801     }
5802
5803   if (do_section_details)
5804     {
5805       if (os_flags)
5806         {
5807           size -= 5 + field_size;
5808           if (p != buff + field_size + 4)
5809             {
5810               if (size < (2 + 1))
5811                 {
5812                   warn (_("Internal error: not enough buffer room for section flag info"));
5813                   return _("<unknown>");
5814                 }
5815               size -= 2;
5816               *p++ = ',';
5817               *p++ = ' ';
5818             }
5819           sprintf (p, "OS (%*.*lx)", field_size, field_size,
5820                    (unsigned long) os_flags);
5821           p += 5 + field_size;
5822         }
5823       if (proc_flags)
5824         {
5825           size -= 7 + field_size;
5826           if (p != buff + field_size + 4)
5827             {
5828               if (size < (2 + 1))
5829                 {
5830                   warn (_("Internal error: not enough buffer room for section flag info"));
5831                   return _("<unknown>");
5832                 }
5833               size -= 2;
5834               *p++ = ',';
5835               *p++ = ' ';
5836             }
5837           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5838                    (unsigned long) proc_flags);
5839           p += 7 + field_size;
5840         }
5841       if (unknown_flags)
5842         {
5843           size -= 10 + field_size;
5844           if (p != buff + field_size + 4)
5845             {
5846               if (size < (2 + 1))
5847                 {
5848                   warn (_("Internal error: not enough buffer room for section flag info"));
5849                   return _("<unknown>");
5850                 }
5851               size -= 2;
5852               *p++ = ',';
5853               *p++ = ' ';
5854             }
5855           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5856                    (unsigned long) unknown_flags);
5857           p += 10 + field_size;
5858         }
5859     }
5860
5861   *p = '\0';
5862   return buff;
5863 }
5864
5865 static unsigned int
5866 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
5867 {
5868   if (is_32bit_elf)
5869     {
5870       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5871
5872       if (size < sizeof (* echdr))
5873         {
5874           error (_("Compressed section is too small even for a compression header\n"));
5875           return 0;
5876         }
5877
5878       chdr->ch_type = BYTE_GET (echdr->ch_type);
5879       chdr->ch_size = BYTE_GET (echdr->ch_size);
5880       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5881       return sizeof (*echdr);
5882     }
5883   else
5884     {
5885       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5886
5887       if (size < sizeof (* echdr))
5888         {
5889           error (_("Compressed section is too small even for a compression header\n"));
5890           return 0;
5891         }
5892
5893       chdr->ch_type = BYTE_GET (echdr->ch_type);
5894       chdr->ch_size = BYTE_GET (echdr->ch_size);
5895       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5896       return sizeof (*echdr);
5897     }
5898 }
5899
5900 static bfd_boolean
5901 process_section_headers (Filedata * filedata)
5902 {
5903   Elf_Internal_Shdr * section;
5904   unsigned int i;
5905
5906   filedata->section_headers = NULL;
5907
5908   if (filedata->file_header.e_shnum == 0)
5909     {
5910       /* PR binutils/12467.  */
5911       if (filedata->file_header.e_shoff != 0)
5912         {
5913           warn (_("possibly corrupt ELF file header - it has a non-zero"
5914                   " section header offset, but no section headers\n"));
5915           return FALSE;
5916         }
5917       else if (do_sections)
5918         printf (_("\nThere are no sections in this file.\n"));
5919
5920       return TRUE;
5921     }
5922
5923   if (do_sections && !do_header)
5924     printf (ngettext ("There is %d section header, "
5925                       "starting at offset 0x%lx:\n",
5926                       "There are %d section headers, "
5927                       "starting at offset 0x%lx:\n",
5928                       filedata->file_header.e_shnum),
5929             filedata->file_header.e_shnum,
5930             (unsigned long) filedata->file_header.e_shoff);
5931
5932   if (is_32bit_elf)
5933     {
5934       if (! get_32bit_section_headers (filedata, FALSE))
5935         return FALSE;
5936     }
5937   else
5938     {
5939       if (! get_64bit_section_headers (filedata, FALSE))
5940         return FALSE;
5941     }
5942
5943   /* Read in the string table, so that we have names to display.  */
5944   if (filedata->file_header.e_shstrndx != SHN_UNDEF
5945        && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
5946     {
5947       section = filedata->section_headers + filedata->file_header.e_shstrndx;
5948
5949       if (section->sh_size != 0)
5950         {
5951           filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
5952                                                       1, section->sh_size,
5953                                                       _("string table"));
5954
5955           filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
5956         }
5957     }
5958
5959   /* Scan the sections for the dynamic symbol table
5960      and dynamic string table and debug sections.  */
5961   dynamic_symbols = NULL;
5962   dynamic_strings = NULL;
5963   dynamic_syminfo = NULL;
5964   symtab_shndx_list = NULL;
5965
5966   eh_addr_size = is_32bit_elf ? 4 : 8;
5967   switch (filedata->file_header.e_machine)
5968     {
5969     case EM_MIPS:
5970     case EM_MIPS_RS3_LE:
5971       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5972          FDE addresses.  However, the ABI also has a semi-official ILP32
5973          variant for which the normal FDE address size rules apply.
5974
5975          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5976          section, where XX is the size of longs in bits.  Unfortunately,
5977          earlier compilers provided no way of distinguishing ILP32 objects
5978          from LP64 objects, so if there's any doubt, we should assume that
5979          the official LP64 form is being used.  */
5980       if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5981           && find_section (filedata, ".gcc_compiled_long32") == NULL)
5982         eh_addr_size = 8;
5983       break;
5984
5985     case EM_H8_300:
5986     case EM_H8_300H:
5987       switch (filedata->file_header.e_flags & EF_H8_MACH)
5988         {
5989         case E_H8_MACH_H8300:
5990         case E_H8_MACH_H8300HN:
5991         case E_H8_MACH_H8300SN:
5992         case E_H8_MACH_H8300SXN:
5993           eh_addr_size = 2;
5994           break;
5995         case E_H8_MACH_H8300H:
5996         case E_H8_MACH_H8300S:
5997         case E_H8_MACH_H8300SX:
5998           eh_addr_size = 4;
5999           break;
6000         }
6001       break;
6002
6003     case EM_M32C_OLD:
6004     case EM_M32C:
6005       switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
6006         {
6007         case EF_M32C_CPU_M16C:
6008           eh_addr_size = 2;
6009           break;
6010         }
6011       break;
6012     }
6013
6014 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
6015   do                                                                    \
6016     {                                                                   \
6017       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
6018       if (section->sh_entsize != expected_entsize)                      \
6019         {                                                               \
6020           char buf[40];                                                 \
6021           sprintf_vma (buf, section->sh_entsize);                       \
6022           /* Note: coded this way so that there is a single string for  \
6023              translation.  */ \
6024           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6025           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6026                    (unsigned) expected_entsize);                        \
6027           section->sh_entsize = expected_entsize;                       \
6028         }                                                               \
6029     }                                                                   \
6030   while (0)
6031
6032 #define CHECK_ENTSIZE(section, i, type)                                 \
6033   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
6034                         sizeof (Elf64_External_##type))
6035
6036   for (i = 0, section = filedata->section_headers;
6037        i < filedata->file_header.e_shnum;
6038        i++, section++)
6039     {
6040       char * name = SECTION_NAME (section);
6041
6042       if (section->sh_type == SHT_DYNSYM)
6043         {
6044           if (dynamic_symbols != NULL)
6045             {
6046               error (_("File contains multiple dynamic symbol tables\n"));
6047               continue;
6048             }
6049
6050           CHECK_ENTSIZE (section, i, Sym);
6051           dynamic_symbols = GET_ELF_SYMBOLS (filedata, section, & num_dynamic_syms);
6052         }
6053       else if (section->sh_type == SHT_STRTAB
6054                && streq (name, ".dynstr"))
6055         {
6056           if (dynamic_strings != NULL)
6057             {
6058               error (_("File contains multiple dynamic string tables\n"));
6059               continue;
6060             }
6061
6062           dynamic_strings = (char *) get_data (NULL, filedata, section->sh_offset,
6063                                                1, section->sh_size,
6064                                                _("dynamic strings"));
6065           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6066         }
6067       else if (section->sh_type == SHT_SYMTAB_SHNDX)
6068         {
6069           elf_section_list * entry = xmalloc (sizeof * entry);
6070
6071           entry->hdr = section;
6072           entry->next = symtab_shndx_list;
6073           symtab_shndx_list = entry;
6074         }
6075       else if (section->sh_type == SHT_SYMTAB)
6076         CHECK_ENTSIZE (section, i, Sym);
6077       else if (section->sh_type == SHT_GROUP)
6078         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6079       else if (section->sh_type == SHT_REL)
6080         CHECK_ENTSIZE (section, i, Rel);
6081       else if (section->sh_type == SHT_RELA)
6082         CHECK_ENTSIZE (section, i, Rela);
6083       else if ((do_debugging || do_debug_info || do_debug_abbrevs
6084                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6085                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6086                 || do_debug_str || do_debug_loc || do_debug_ranges
6087                 || do_debug_addr || do_debug_cu_index)
6088                && (const_strneq (name, ".debug_")
6089                    || const_strneq (name, ".zdebug_")))
6090         {
6091           if (name[1] == 'z')
6092             name += sizeof (".zdebug_") - 1;
6093           else
6094             name += sizeof (".debug_") - 1;
6095
6096           if (do_debugging
6097               || (do_debug_info     && const_strneq (name, "info"))
6098               || (do_debug_info     && const_strneq (name, "types"))
6099               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
6100               || (do_debug_lines    && strcmp (name, "line") == 0)
6101               || (do_debug_lines    && const_strneq (name, "line."))
6102               || (do_debug_pubnames && const_strneq (name, "pubnames"))
6103               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6104               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6105               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6106               || (do_debug_aranges  && const_strneq (name, "aranges"))
6107               || (do_debug_ranges   && const_strneq (name, "ranges"))
6108               || (do_debug_ranges   && const_strneq (name, "rnglists"))
6109               || (do_debug_frames   && const_strneq (name, "frame"))
6110               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
6111               || (do_debug_macinfo  && const_strneq (name, "macro"))
6112               || (do_debug_str      && const_strneq (name, "str"))
6113               || (do_debug_loc      && const_strneq (name, "loc"))
6114               || (do_debug_loc      && const_strneq (name, "loclists"))
6115               || (do_debug_addr     && const_strneq (name, "addr"))
6116               || (do_debug_cu_index && const_strneq (name, "cu_index"))
6117               || (do_debug_cu_index && const_strneq (name, "tu_index"))
6118               )
6119             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6120         }
6121       /* Linkonce section to be combined with .debug_info at link time.  */
6122       else if ((do_debugging || do_debug_info)
6123                && const_strneq (name, ".gnu.linkonce.wi."))
6124         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6125       else if (do_debug_frames && streq (name, ".eh_frame"))
6126         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6127       else if (do_gdb_index && (streq (name, ".gdb_index")
6128                                 || streq (name, ".debug_names")))
6129         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6130       /* Trace sections for Itanium VMS.  */
6131       else if ((do_debugging || do_trace_info || do_trace_abbrevs
6132                 || do_trace_aranges)
6133                && const_strneq (name, ".trace_"))
6134         {
6135           name += sizeof (".trace_") - 1;
6136
6137           if (do_debugging
6138               || (do_trace_info     && streq (name, "info"))
6139               || (do_trace_abbrevs  && streq (name, "abbrev"))
6140               || (do_trace_aranges  && streq (name, "aranges"))
6141               )
6142             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6143         }
6144       else if ((do_debugging || do_debug_links)
6145                && (const_strneq (name, ".gnu_debuglink")
6146                    || const_strneq (name, ".gnu_debugaltlink")))
6147         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6148     }
6149
6150   if (! do_sections)
6151     return TRUE;
6152
6153   if (filedata->file_header.e_shnum > 1)
6154     printf (_("\nSection Headers:\n"));
6155   else
6156     printf (_("\nSection Header:\n"));
6157
6158   if (is_32bit_elf)
6159     {
6160       if (do_section_details)
6161         {
6162           printf (_("  [Nr] Name\n"));
6163           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
6164         }
6165       else
6166         printf
6167           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
6168     }
6169   else if (do_wide)
6170     {
6171       if (do_section_details)
6172         {
6173           printf (_("  [Nr] Name\n"));
6174           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
6175         }
6176       else
6177         printf
6178           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
6179     }
6180   else
6181     {
6182       if (do_section_details)
6183         {
6184           printf (_("  [Nr] Name\n"));
6185           printf (_("       Type              Address          Offset            Link\n"));
6186           printf (_("       Size              EntSize          Info              Align\n"));
6187         }
6188       else
6189         {
6190           printf (_("  [Nr] Name              Type             Address           Offset\n"));
6191           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
6192         }
6193     }
6194
6195   if (do_section_details)
6196     printf (_("       Flags\n"));
6197
6198   for (i = 0, section = filedata->section_headers;
6199        i < filedata->file_header.e_shnum;
6200        i++, section++)
6201     {
6202       /* Run some sanity checks on the section header.  */
6203
6204       /* Check the sh_link field.  */
6205       switch (section->sh_type)
6206         {
6207         case SHT_SYMTAB_SHNDX:
6208         case SHT_GROUP:
6209         case SHT_HASH:
6210         case SHT_GNU_HASH:
6211         case SHT_GNU_versym:
6212         case SHT_REL:
6213         case SHT_RELA:
6214           if (section->sh_link < 1
6215               || section->sh_link >= filedata->file_header.e_shnum
6216               || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6217                   && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6218             warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6219                   i, section->sh_link);
6220           break;
6221
6222         case SHT_DYNAMIC:
6223         case SHT_SYMTAB:
6224         case SHT_DYNSYM:
6225         case SHT_GNU_verneed:
6226         case SHT_GNU_verdef:
6227         case SHT_GNU_LIBLIST:
6228           if (section->sh_link < 1
6229               || section->sh_link >= filedata->file_header.e_shnum
6230               || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6231             warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6232                   i, section->sh_link);
6233           break;
6234
6235         case SHT_INIT_ARRAY:
6236         case SHT_FINI_ARRAY:
6237         case SHT_PREINIT_ARRAY:
6238           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6239             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6240                   i, section->sh_link);
6241           break;
6242
6243         default:
6244           /* FIXME: Add support for target specific section types.  */
6245 #if 0     /* Currently we do not check other section types as there are too
6246              many special cases.  Stab sections for example have a type
6247              of SHT_PROGBITS but an sh_link field that links to the .stabstr
6248              section.  */
6249           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6250             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6251                   i, section->sh_link);
6252 #endif
6253           break;
6254         }
6255
6256       /* Check the sh_info field.  */
6257       switch (section->sh_type)
6258         {
6259         case SHT_REL:
6260         case SHT_RELA:
6261           if (section->sh_info < 1
6262               || section->sh_info >= filedata->file_header.e_shnum
6263               || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6264                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6265                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6266                   && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6267                   /* FIXME: Are other section types valid ?  */
6268                   && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6269             {
6270               if (section->sh_info == 0
6271                   && (streq (SECTION_NAME (section), ".rel.dyn")
6272                       || streq (SECTION_NAME (section), ".rela.dyn")))
6273                 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6274                    of zero.  The relocations in these sections may apply
6275                    to many different sections.  */
6276                    ;
6277               else
6278                 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6279                       i, section->sh_info);
6280             }
6281           break;
6282
6283         case SHT_DYNAMIC:
6284         case SHT_HASH:
6285         case SHT_SYMTAB_SHNDX:
6286         case SHT_INIT_ARRAY:
6287         case SHT_FINI_ARRAY:
6288         case SHT_PREINIT_ARRAY:
6289           if (section->sh_info != 0)
6290             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6291                   i, section->sh_info);
6292           break;
6293
6294         case SHT_GROUP:
6295         case SHT_SYMTAB:
6296         case SHT_DYNSYM:
6297           /* A symbol index - we assume that it is valid.  */
6298           break;
6299
6300         default:
6301           /* FIXME: Add support for target specific section types.  */
6302           if (section->sh_type == SHT_NOBITS)
6303             /* NOBITS section headers with non-zero sh_info fields can be
6304                created when a binary is stripped of everything but its debug
6305                information.  The stripped sections have their headers
6306                preserved but their types set to SHT_NOBITS.  So do not check
6307                this type of section.  */
6308             ;
6309           else if (section->sh_flags & SHF_INFO_LINK)
6310             {
6311               if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6312                 warn (_("[%2u]: Expected link to another section in info field"), i);
6313             }
6314           else if (section->sh_type < SHT_LOOS
6315                    && (section->sh_flags & SHF_GNU_MBIND) == 0
6316                    && section->sh_info != 0)
6317             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6318                   i, section->sh_info);
6319           break;
6320         }
6321
6322       /* Check the sh_size field.  */
6323       if (section->sh_size > filedata->file_size
6324           && section->sh_type != SHT_NOBITS
6325           && section->sh_type != SHT_NULL
6326           && section->sh_type < SHT_LOOS)
6327         warn (_("Size of section %u is larger than the entire file!\n"), i);
6328
6329       printf ("  [%2u] ", i);
6330       if (do_section_details)
6331         printf ("%s\n      ", printable_section_name (filedata, section));
6332       else
6333         print_symbol (-17, SECTION_NAME (section));
6334
6335       printf (do_wide ? " %-15s " : " %-15.15s ",
6336               get_section_type_name (filedata, section->sh_type));
6337
6338       if (is_32bit_elf)
6339         {
6340           const char * link_too_big = NULL;
6341
6342           print_vma (section->sh_addr, LONG_HEX);
6343
6344           printf ( " %6.6lx %6.6lx %2.2lx",
6345                    (unsigned long) section->sh_offset,
6346                    (unsigned long) section->sh_size,
6347                    (unsigned long) section->sh_entsize);
6348
6349           if (do_section_details)
6350             fputs ("  ", stdout);
6351           else
6352             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6353
6354           if (section->sh_link >= filedata->file_header.e_shnum)
6355             {
6356               link_too_big = "";
6357               /* The sh_link value is out of range.  Normally this indicates
6358                  an error but it can have special values in Solaris binaries.  */
6359               switch (filedata->file_header.e_machine)
6360                 {
6361                 case EM_386:
6362                 case EM_IAMCU:
6363                 case EM_X86_64:
6364                 case EM_L1OM:
6365                 case EM_K1OM:
6366                 case EM_OLD_SPARCV9:
6367                 case EM_SPARC32PLUS:
6368                 case EM_SPARCV9:
6369                 case EM_SPARC:
6370                   if (section->sh_link == (SHN_BEFORE & 0xffff))
6371                     link_too_big = "BEFORE";
6372                   else if (section->sh_link == (SHN_AFTER & 0xffff))
6373                     link_too_big = "AFTER";
6374                   break;
6375                 default:
6376                   break;
6377                 }
6378             }
6379
6380           if (do_section_details)
6381             {
6382               if (link_too_big != NULL && * link_too_big)
6383                 printf ("<%s> ", link_too_big);
6384               else
6385                 printf ("%2u ", section->sh_link);
6386               printf ("%3u %2lu\n", section->sh_info,
6387                       (unsigned long) section->sh_addralign);
6388             }
6389           else
6390             printf ("%2u %3u %2lu\n",
6391                     section->sh_link,
6392                     section->sh_info,
6393                     (unsigned long) section->sh_addralign);
6394
6395           if (link_too_big && ! * link_too_big)
6396             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6397                   i, section->sh_link);
6398         }
6399       else if (do_wide)
6400         {
6401           print_vma (section->sh_addr, LONG_HEX);
6402
6403           if ((long) section->sh_offset == section->sh_offset)
6404             printf (" %6.6lx", (unsigned long) section->sh_offset);
6405           else
6406             {
6407               putchar (' ');
6408               print_vma (section->sh_offset, LONG_HEX);
6409             }
6410
6411           if ((unsigned long) section->sh_size == section->sh_size)
6412             printf (" %6.6lx", (unsigned long) section->sh_size);
6413           else
6414             {
6415               putchar (' ');
6416               print_vma (section->sh_size, LONG_HEX);
6417             }
6418
6419           if ((unsigned long) section->sh_entsize == section->sh_entsize)
6420             printf (" %2.2lx", (unsigned long) section->sh_entsize);
6421           else
6422             {
6423               putchar (' ');
6424               print_vma (section->sh_entsize, LONG_HEX);
6425             }
6426
6427           if (do_section_details)
6428             fputs ("  ", stdout);
6429           else
6430             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6431
6432           printf ("%2u %3u ", section->sh_link, section->sh_info);
6433
6434           if ((unsigned long) section->sh_addralign == section->sh_addralign)
6435             printf ("%2lu\n", (unsigned long) section->sh_addralign);
6436           else
6437             {
6438               print_vma (section->sh_addralign, DEC);
6439               putchar ('\n');
6440             }
6441         }
6442       else if (do_section_details)
6443         {
6444           printf ("       %-15.15s  ",
6445                   get_section_type_name (filedata, section->sh_type));
6446           print_vma (section->sh_addr, LONG_HEX);
6447           if ((long) section->sh_offset == section->sh_offset)
6448             printf ("  %16.16lx", (unsigned long) section->sh_offset);
6449           else
6450             {
6451               printf ("  ");
6452               print_vma (section->sh_offset, LONG_HEX);
6453             }
6454           printf ("  %u\n       ", section->sh_link);
6455           print_vma (section->sh_size, LONG_HEX);
6456           putchar (' ');
6457           print_vma (section->sh_entsize, LONG_HEX);
6458
6459           printf ("  %-16u  %lu\n",
6460                   section->sh_info,
6461                   (unsigned long) section->sh_addralign);
6462         }
6463       else
6464         {
6465           putchar (' ');
6466           print_vma (section->sh_addr, LONG_HEX);
6467           if ((long) section->sh_offset == section->sh_offset)
6468             printf ("  %8.8lx", (unsigned long) section->sh_offset);
6469           else
6470             {
6471               printf ("  ");
6472               print_vma (section->sh_offset, LONG_HEX);
6473             }
6474           printf ("\n       ");
6475           print_vma (section->sh_size, LONG_HEX);
6476           printf ("  ");
6477           print_vma (section->sh_entsize, LONG_HEX);
6478
6479           printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6480
6481           printf ("     %2u   %3u     %lu\n",
6482                   section->sh_link,
6483                   section->sh_info,
6484                   (unsigned long) section->sh_addralign);
6485         }
6486
6487       if (do_section_details)
6488         {
6489           printf ("       %s\n", get_elf_section_flags (filedata, section->sh_flags));
6490           if ((section->sh_flags & SHF_COMPRESSED) != 0)
6491             {
6492               /* Minimum section size is 12 bytes for 32-bit compression
6493                  header + 12 bytes for compressed data header.  */
6494               unsigned char buf[24];
6495
6496               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6497               if (get_data (&buf, filedata, section->sh_offset, 1,
6498                             sizeof (buf), _("compression header")))
6499                 {
6500                   Elf_Internal_Chdr chdr;
6501
6502                   (void) get_compression_header (&chdr, buf, sizeof (buf));
6503
6504                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6505                     printf ("       ZLIB, ");
6506                   else
6507                     printf (_("       [<unknown>: 0x%x], "),
6508                             chdr.ch_type);
6509                   print_vma (chdr.ch_size, LONG_HEX);
6510                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6511                 }
6512             }
6513         }
6514     }
6515
6516   if (!do_section_details)
6517     {
6518       /* The ordering of the letters shown here matches the ordering of the
6519          corresponding SHF_xxx values, and hence the order in which these
6520          letters will be displayed to the user.  */
6521       printf (_("Key to Flags:\n\
6522   W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6523   L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6524   C (compressed), x (unknown), o (OS specific), E (exclude),\n  "));
6525       if (filedata->file_header.e_machine == EM_X86_64
6526           || filedata->file_header.e_machine == EM_L1OM
6527           || filedata->file_header.e_machine == EM_K1OM)
6528         printf (_("l (large), "));
6529       else if (filedata->file_header.e_machine == EM_ARM)
6530         printf (_("y (purecode), "));
6531       else if (filedata->file_header.e_machine == EM_PPC)
6532         printf (_("v (VLE), "));
6533       printf ("p (processor specific)\n");
6534     }
6535
6536   return TRUE;
6537 }
6538
6539 static const char *
6540 get_group_flags (unsigned int flags)
6541 {
6542   static char buff[128];
6543
6544   if (flags == 0)
6545     return "";
6546   else if (flags == GRP_COMDAT)
6547     return "COMDAT ";
6548
6549   snprintf (buff, 14, _("[0x%x: "), flags);
6550
6551   flags &= ~ GRP_COMDAT;
6552   if (flags & GRP_MASKOS)
6553     {
6554       strcat (buff, "<OS specific>");
6555       flags &= ~ GRP_MASKOS;
6556     }
6557
6558   if (flags & GRP_MASKPROC)
6559     {
6560       strcat (buff, "<PROC specific>");
6561       flags &= ~ GRP_MASKPROC;
6562     }
6563
6564   if (flags)
6565     strcat (buff, "<unknown>");
6566
6567   strcat (buff, "]");
6568   return buff;
6569 }
6570
6571 static bfd_boolean
6572 process_section_groups (Filedata * filedata)
6573 {
6574   Elf_Internal_Shdr * section;
6575   unsigned int i;
6576   struct group * group;
6577   Elf_Internal_Shdr * symtab_sec;
6578   Elf_Internal_Shdr * strtab_sec;
6579   Elf_Internal_Sym * symtab;
6580   unsigned long num_syms;
6581   char * strtab;
6582   size_t strtab_size;
6583
6584   /* Don't process section groups unless needed.  */
6585   if (!do_unwind && !do_section_groups)
6586     return TRUE;
6587
6588   if (filedata->file_header.e_shnum == 0)
6589     {
6590       if (do_section_groups)
6591         printf (_("\nThere are no sections to group in this file.\n"));
6592
6593       return TRUE;
6594     }
6595
6596   if (filedata->section_headers == NULL)
6597     {
6598       error (_("Section headers are not available!\n"));
6599       /* PR 13622: This can happen with a corrupt ELF header.  */
6600       return FALSE;
6601     }
6602
6603   section_headers_groups = (struct group **) calloc (filedata->file_header.e_shnum,
6604                                                      sizeof (struct group *));
6605
6606   if (section_headers_groups == NULL)
6607     {
6608       error (_("Out of memory reading %u section group headers\n"),
6609              filedata->file_header.e_shnum);
6610       return FALSE;
6611     }
6612
6613   /* Scan the sections for the group section.  */
6614   group_count = 0;
6615   for (i = 0, section = filedata->section_headers;
6616        i < filedata->file_header.e_shnum;
6617        i++, section++)
6618     if (section->sh_type == SHT_GROUP)
6619       group_count++;
6620
6621   if (group_count == 0)
6622     {
6623       if (do_section_groups)
6624         printf (_("\nThere are no section groups in this file.\n"));
6625
6626       return TRUE;
6627     }
6628
6629   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6630
6631   if (section_groups == NULL)
6632     {
6633       error (_("Out of memory reading %lu groups\n"),
6634              (unsigned long) group_count);
6635       return FALSE;
6636     }
6637
6638   symtab_sec = NULL;
6639   strtab_sec = NULL;
6640   symtab = NULL;
6641   num_syms = 0;
6642   strtab = NULL;
6643   strtab_size = 0;
6644   for (i = 0, section = filedata->section_headers, group = section_groups;
6645        i < filedata->file_header.e_shnum;
6646        i++, section++)
6647     {
6648       if (section->sh_type == SHT_GROUP)
6649         {
6650           const char * name = printable_section_name (filedata, section);
6651           const char * group_name;
6652           unsigned char * start;
6653           unsigned char * indices;
6654           unsigned int entry, j, size;
6655           Elf_Internal_Shdr * sec;
6656           Elf_Internal_Sym * sym;
6657
6658           /* Get the symbol table.  */
6659           if (section->sh_link >= filedata->file_header.e_shnum
6660               || ((sec = filedata->section_headers + section->sh_link)->sh_type
6661                   != SHT_SYMTAB))
6662             {
6663               error (_("Bad sh_link in group section `%s'\n"), name);
6664               continue;
6665             }
6666
6667           if (symtab_sec != sec)
6668             {
6669               symtab_sec = sec;
6670               if (symtab)
6671                 free (symtab);
6672               symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
6673             }
6674
6675           if (symtab == NULL)
6676             {
6677               error (_("Corrupt header in group section `%s'\n"), name);
6678               continue;
6679             }
6680
6681           if (section->sh_info >= num_syms)
6682             {
6683               error (_("Bad sh_info in group section `%s'\n"), name);
6684               continue;
6685             }
6686
6687           sym = symtab + section->sh_info;
6688
6689           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6690             {
6691               if (sym->st_shndx == 0
6692                   || sym->st_shndx >= filedata->file_header.e_shnum)
6693                 {
6694                   error (_("Bad sh_info in group section `%s'\n"), name);
6695                   continue;
6696                 }
6697
6698               group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
6699               strtab_sec = NULL;
6700               if (strtab)
6701                 free (strtab);
6702               strtab = NULL;
6703               strtab_size = 0;
6704             }
6705           else
6706             {
6707               /* Get the string table.  */
6708               if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
6709                 {
6710                   strtab_sec = NULL;
6711                   if (strtab)
6712                     free (strtab);
6713                   strtab = NULL;
6714                   strtab_size = 0;
6715                 }
6716               else if (strtab_sec
6717                        != (sec = filedata->section_headers + symtab_sec->sh_link))
6718                 {
6719                   strtab_sec = sec;
6720                   if (strtab)
6721                     free (strtab);
6722
6723                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
6724                                               1, strtab_sec->sh_size,
6725                                               _("string table"));
6726                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6727                 }
6728               group_name = sym->st_name < strtab_size
6729                 ? strtab + sym->st_name : _("<corrupt>");
6730             }
6731
6732           /* PR 17531: file: loop.  */
6733           if (section->sh_entsize > section->sh_size)
6734             {
6735               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6736                      printable_section_name (filedata, section),
6737                      (unsigned long) section->sh_entsize,
6738                      (unsigned long) section->sh_size);
6739               break;
6740             }
6741
6742           start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
6743                                               1, section->sh_size,
6744                                               _("section data"));
6745           if (start == NULL)
6746             continue;
6747
6748           indices = start;
6749           size = (section->sh_size / section->sh_entsize) - 1;
6750           entry = byte_get (indices, 4);
6751           indices += 4;
6752
6753           if (do_section_groups)
6754             {
6755               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6756                       get_group_flags (entry), i, name, group_name, size);
6757
6758               printf (_("   [Index]    Name\n"));
6759             }
6760
6761           group->group_index = i;
6762
6763           for (j = 0; j < size; j++)
6764             {
6765               struct group_list * g;
6766
6767               entry = byte_get (indices, 4);
6768               indices += 4;
6769
6770               if (entry >= filedata->file_header.e_shnum)
6771                 {
6772                   static unsigned num_group_errors = 0;
6773
6774                   if (num_group_errors ++ < 10)
6775                     {
6776                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6777                              entry, i, filedata->file_header.e_shnum - 1);
6778                       if (num_group_errors == 10)
6779                         warn (_("Further error messages about overlarge group section indicies suppressed\n"));
6780                     }
6781                   continue;
6782                 }
6783
6784               if (section_headers_groups [entry] != NULL)
6785                 {
6786                   if (entry)
6787                     {
6788                       static unsigned num_errs = 0;
6789
6790                       if (num_errs ++ < 10)
6791                         {
6792                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6793                                  entry, i,
6794                                  section_headers_groups [entry]->group_index);
6795                           if (num_errs == 10)
6796                             warn (_("Further error messages about already contained group sections suppressed\n"));
6797                         }
6798                       continue;
6799                     }
6800                   else
6801                     {
6802                       /* Intel C/C++ compiler may put section 0 in a
6803                          section group.  We just warn it the first time
6804                          and ignore it afterwards.  */
6805                       static bfd_boolean warned = FALSE;
6806                       if (!warned)
6807                         {
6808                           error (_("section 0 in group section [%5u]\n"),
6809                                  section_headers_groups [entry]->group_index);
6810                           warned = TRUE;
6811                         }
6812                     }
6813                 }
6814
6815               section_headers_groups [entry] = group;
6816
6817               if (do_section_groups)
6818                 {
6819                   sec = filedata->section_headers + entry;
6820                   printf ("   [%5u]   %s\n", entry, printable_section_name (filedata, sec));
6821                 }
6822
6823               g = (struct group_list *) xmalloc (sizeof (struct group_list));
6824               g->section_index = entry;
6825               g->next = group->root;
6826               group->root = g;
6827             }
6828
6829           if (start)
6830             free (start);
6831
6832           group++;
6833         }
6834     }
6835
6836   if (symtab)
6837     free (symtab);
6838   if (strtab)
6839     free (strtab);
6840   return TRUE;
6841 }
6842
6843 /* Data used to display dynamic fixups.  */
6844
6845 struct ia64_vms_dynfixup
6846 {
6847   bfd_vma needed_ident;         /* Library ident number.  */
6848   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
6849   bfd_vma fixup_needed;         /* Index of the library.  */
6850   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
6851   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
6852 };
6853
6854 /* Data used to display dynamic relocations.  */
6855
6856 struct ia64_vms_dynimgrela
6857 {
6858   bfd_vma img_rela_cnt;         /* Number of relocations.  */
6859   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
6860 };
6861
6862 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6863    library).  */
6864
6865 static bfd_boolean
6866 dump_ia64_vms_dynamic_fixups (Filedata *                  filedata,
6867                               struct ia64_vms_dynfixup *  fixup,
6868                               const char *                strtab,
6869                               unsigned int                strtab_sz)
6870 {
6871   Elf64_External_VMS_IMAGE_FIXUP * imfs;
6872   long i;
6873   const char * lib_name;
6874
6875   imfs = get_data (NULL, filedata, dynamic_addr + fixup->fixup_rela_off,
6876                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
6877                    _("dynamic section image fixups"));
6878   if (!imfs)
6879     return FALSE;
6880
6881   if (fixup->needed < strtab_sz)
6882     lib_name = strtab + fixup->needed;
6883   else
6884     {
6885       warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6886             (unsigned long) fixup->needed);
6887       lib_name = "???";
6888     }
6889   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6890           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6891   printf
6892     (_("Seg Offset           Type                             SymVec DataType\n"));
6893
6894   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6895     {
6896       unsigned int type;
6897       const char *rtype;
6898
6899       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6900       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6901       type = BYTE_GET (imfs [i].type);
6902       rtype = elf_ia64_reloc_type (type);
6903       if (rtype == NULL)
6904         printf (" 0x%08x                       ", type);
6905       else
6906         printf (" %-32s ", rtype);
6907       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6908       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6909     }
6910
6911   free (imfs);
6912   return TRUE;
6913 }
6914
6915 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
6916
6917 static bfd_boolean
6918 dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
6919 {
6920   Elf64_External_VMS_IMAGE_RELA *imrs;
6921   long i;
6922
6923   imrs = get_data (NULL, filedata, dynamic_addr + imgrela->img_rela_off,
6924                    1, imgrela->img_rela_cnt * sizeof (*imrs),
6925                    _("dynamic section image relocations"));
6926   if (!imrs)
6927     return FALSE;
6928
6929   printf (_("\nImage relocs\n"));
6930   printf
6931     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
6932
6933   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6934     {
6935       unsigned int type;
6936       const char *rtype;
6937
6938       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6939       printf ("%08" BFD_VMA_FMT "x ",
6940               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6941       type = BYTE_GET (imrs [i].type);
6942       rtype = elf_ia64_reloc_type (type);
6943       if (rtype == NULL)
6944         printf ("0x%08x                      ", type);
6945       else
6946         printf ("%-31s ", rtype);
6947       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6948       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6949       printf ("%08" BFD_VMA_FMT "x\n",
6950               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6951     }
6952
6953   free (imrs);
6954   return TRUE;
6955 }
6956
6957 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
6958
6959 static bfd_boolean
6960 process_ia64_vms_dynamic_relocs (Filedata * filedata)
6961 {
6962   struct ia64_vms_dynfixup fixup;
6963   struct ia64_vms_dynimgrela imgrela;
6964   Elf_Internal_Dyn *entry;
6965   bfd_vma strtab_off = 0;
6966   bfd_vma strtab_sz = 0;
6967   char *strtab = NULL;
6968   bfd_boolean res = TRUE;
6969
6970   memset (&fixup, 0, sizeof (fixup));
6971   memset (&imgrela, 0, sizeof (imgrela));
6972
6973   /* Note: the order of the entries is specified by the OpenVMS specs.  */
6974   for (entry = dynamic_section;
6975        entry < dynamic_section + dynamic_nent;
6976        entry++)
6977     {
6978       switch (entry->d_tag)
6979         {
6980         case DT_IA_64_VMS_STRTAB_OFFSET:
6981           strtab_off = entry->d_un.d_val;
6982           break;
6983         case DT_STRSZ:
6984           strtab_sz = entry->d_un.d_val;
6985           if (strtab == NULL)
6986             strtab = get_data (NULL, filedata, dynamic_addr + strtab_off,
6987                                1, strtab_sz, _("dynamic string section"));
6988           break;
6989
6990         case DT_IA_64_VMS_NEEDED_IDENT:
6991           fixup.needed_ident = entry->d_un.d_val;
6992           break;
6993         case DT_NEEDED:
6994           fixup.needed = entry->d_un.d_val;
6995           break;
6996         case DT_IA_64_VMS_FIXUP_NEEDED:
6997           fixup.fixup_needed = entry->d_un.d_val;
6998           break;
6999         case DT_IA_64_VMS_FIXUP_RELA_CNT:
7000           fixup.fixup_rela_cnt = entry->d_un.d_val;
7001           break;
7002         case DT_IA_64_VMS_FIXUP_RELA_OFF:
7003           fixup.fixup_rela_off = entry->d_un.d_val;
7004           if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7005             res = FALSE;
7006           break;
7007         case DT_IA_64_VMS_IMG_RELA_CNT:
7008           imgrela.img_rela_cnt = entry->d_un.d_val;
7009           break;
7010         case DT_IA_64_VMS_IMG_RELA_OFF:
7011           imgrela.img_rela_off = entry->d_un.d_val;
7012           if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7013             res = FALSE;
7014           break;
7015
7016         default:
7017           break;
7018         }
7019     }
7020
7021   if (strtab != NULL)
7022     free (strtab);
7023
7024   return res;
7025 }
7026
7027 static struct
7028 {
7029   const char * name;
7030   int reloc;
7031   int size;
7032   int rela;
7033 }
7034   dynamic_relocations [] =
7035 {
7036   { "REL", DT_REL, DT_RELSZ, FALSE },
7037   { "RELA", DT_RELA, DT_RELASZ, TRUE },
7038   { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7039 };
7040
7041 /* Process the reloc section.  */
7042
7043 static bfd_boolean
7044 process_relocs (Filedata * filedata)
7045 {
7046   unsigned long rel_size;
7047   unsigned long rel_offset;
7048
7049   if (!do_reloc)
7050     return TRUE;
7051
7052   if (do_using_dynamic)
7053     {
7054       int          is_rela;
7055       const char * name;
7056       bfd_boolean  has_dynamic_reloc;
7057       unsigned int i;
7058
7059       has_dynamic_reloc = FALSE;
7060
7061       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7062         {
7063           is_rela = dynamic_relocations [i].rela;
7064           name = dynamic_relocations [i].name;
7065           rel_size = dynamic_info [dynamic_relocations [i].size];
7066           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7067
7068           if (rel_size)
7069             has_dynamic_reloc = TRUE;
7070
7071           if (is_rela == UNKNOWN)
7072             {
7073               if (dynamic_relocations [i].reloc == DT_JMPREL)
7074                 switch (dynamic_info[DT_PLTREL])
7075                   {
7076                   case DT_REL:
7077                     is_rela = FALSE;
7078                     break;
7079                   case DT_RELA:
7080                     is_rela = TRUE;
7081                     break;
7082                   }
7083             }
7084
7085           if (rel_size)
7086             {
7087               printf
7088                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7089                  name, rel_offset, rel_size);
7090
7091               dump_relocations (filedata,
7092                                 offset_from_vma (filedata, rel_offset, rel_size),
7093                                 rel_size,
7094                                 dynamic_symbols, num_dynamic_syms,
7095                                 dynamic_strings, dynamic_strings_length,
7096                                 is_rela, TRUE /* is_dynamic */);
7097             }
7098         }
7099
7100       if (is_ia64_vms (filedata))
7101         if (process_ia64_vms_dynamic_relocs (filedata))
7102           has_dynamic_reloc = TRUE;
7103
7104       if (! has_dynamic_reloc)
7105         printf (_("\nThere are no dynamic relocations in this file.\n"));
7106     }
7107   else
7108     {
7109       Elf_Internal_Shdr * section;
7110       unsigned long i;
7111       bfd_boolean found = FALSE;
7112
7113       for (i = 0, section = filedata->section_headers;
7114            i < filedata->file_header.e_shnum;
7115            i++, section++)
7116         {
7117           if (   section->sh_type != SHT_RELA
7118               && section->sh_type != SHT_REL)
7119             continue;
7120
7121           rel_offset = section->sh_offset;
7122           rel_size   = section->sh_size;
7123
7124           if (rel_size)
7125             {
7126               Elf_Internal_Shdr * strsec;
7127               int is_rela;
7128               unsigned long num_rela;
7129
7130               printf (_("\nRelocation section "));
7131
7132               if (filedata->string_table == NULL)
7133                 printf ("%d", section->sh_name);
7134               else
7135                 printf ("'%s'", printable_section_name (filedata, section));
7136
7137               num_rela = rel_size / section->sh_entsize;
7138               printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7139                                 " at offset 0x%lx contains %lu entries:\n",
7140                                 num_rela),
7141                       rel_offset, num_rela);
7142
7143               is_rela = section->sh_type == SHT_RELA;
7144
7145               if (section->sh_link != 0
7146                   && section->sh_link < filedata->file_header.e_shnum)
7147                 {
7148                   Elf_Internal_Shdr * symsec;
7149                   Elf_Internal_Sym *  symtab;
7150                   unsigned long nsyms;
7151                   unsigned long strtablen = 0;
7152                   char * strtab = NULL;
7153
7154                   symsec = filedata->section_headers + section->sh_link;
7155                   if (symsec->sh_type != SHT_SYMTAB
7156                       && symsec->sh_type != SHT_DYNSYM)
7157                     continue;
7158
7159                   symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
7160
7161                   if (symtab == NULL)
7162                     continue;
7163
7164                   if (symsec->sh_link != 0
7165                       && symsec->sh_link < filedata->file_header.e_shnum)
7166                     {
7167                       strsec = filedata->section_headers + symsec->sh_link;
7168
7169                       strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7170                                                   1, strsec->sh_size,
7171                                                   _("string table"));
7172                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
7173                     }
7174
7175                   dump_relocations (filedata, rel_offset, rel_size,
7176                                     symtab, nsyms, strtab, strtablen,
7177                                     is_rela,
7178                                     symsec->sh_type == SHT_DYNSYM);
7179                   if (strtab)
7180                     free (strtab);
7181                   free (symtab);
7182                 }
7183               else
7184                 dump_relocations (filedata, rel_offset, rel_size,
7185                                   NULL, 0, NULL, 0, is_rela,
7186                                   FALSE /* is_dynamic */);
7187
7188               found = TRUE;
7189             }
7190         }
7191
7192       if (! found)
7193         {
7194           /* Users sometimes forget the -D option, so try to be helpful.  */
7195           for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7196             {
7197               if (dynamic_info [dynamic_relocations [i].size])
7198                 {
7199                   printf (_("\nThere are no static relocations in this file."));
7200                   printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7201
7202                   break;
7203                 }
7204             }
7205           if (i == ARRAY_SIZE (dynamic_relocations))
7206             printf (_("\nThere are no relocations in this file.\n"));
7207         }
7208     }
7209
7210   return TRUE;
7211 }
7212
7213 /* An absolute address consists of a section and an offset.  If the
7214    section is NULL, the offset itself is the address, otherwise, the
7215    address equals to LOAD_ADDRESS(section) + offset.  */
7216
7217 struct absaddr
7218 {
7219   unsigned short section;
7220   bfd_vma offset;
7221 };
7222
7223 #define ABSADDR(a) \
7224   ((a).section \
7225    ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7226    : (a).offset)
7227
7228 /* Find the nearest symbol at or below ADDR.  Returns the symbol
7229    name, if found, and the offset from the symbol to ADDR.  */
7230
7231 static void
7232 find_symbol_for_address (Filedata *          filedata,
7233                          Elf_Internal_Sym *  symtab,
7234                          unsigned long       nsyms,
7235                          const char *        strtab,
7236                          unsigned long       strtab_size,
7237                          struct absaddr      addr,
7238                          const char **       symname,
7239                          bfd_vma *           offset)
7240 {
7241   bfd_vma dist = 0x100000;
7242   Elf_Internal_Sym * sym;
7243   Elf_Internal_Sym * beg;
7244   Elf_Internal_Sym * end;
7245   Elf_Internal_Sym * best = NULL;
7246
7247   REMOVE_ARCH_BITS (addr.offset);
7248   beg = symtab;
7249   end = symtab + nsyms;
7250
7251   while (beg < end)
7252     {
7253       bfd_vma value;
7254
7255       sym = beg + (end - beg) / 2;
7256
7257       value = sym->st_value;
7258       REMOVE_ARCH_BITS (value);
7259
7260       if (sym->st_name != 0
7261           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7262           && addr.offset >= value
7263           && addr.offset - value < dist)
7264         {
7265           best = sym;
7266           dist = addr.offset - value;
7267           if (!dist)
7268             break;
7269         }
7270
7271       if (addr.offset < value)
7272         end = sym;
7273       else
7274         beg = sym + 1;
7275     }
7276
7277   if (best)
7278     {
7279       *symname = (best->st_name >= strtab_size
7280                   ? _("<corrupt>") : strtab + best->st_name);
7281       *offset = dist;
7282       return;
7283     }
7284
7285   *symname = NULL;
7286   *offset = addr.offset;
7287 }
7288
7289 static /* signed */ int
7290 symcmp (const void *p, const void *q)
7291 {
7292   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7293   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7294
7295   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7296 }
7297
7298 /* Process the unwind section.  */
7299
7300 #include "unwind-ia64.h"
7301
7302 struct ia64_unw_table_entry
7303 {
7304   struct absaddr start;
7305   struct absaddr end;
7306   struct absaddr info;
7307 };
7308
7309 struct ia64_unw_aux_info
7310 {
7311   struct ia64_unw_table_entry * table;          /* Unwind table.  */
7312   unsigned long                 table_len;      /* Length of unwind table.  */
7313   unsigned char *               info;           /* Unwind info.  */
7314   unsigned long                 info_size;      /* Size of unwind info.  */
7315   bfd_vma                       info_addr;      /* Starting address of unwind info.  */
7316   bfd_vma                       seg_base;       /* Starting address of segment.  */
7317   Elf_Internal_Sym *            symtab;         /* The symbol table.  */
7318   unsigned long                 nsyms;          /* Number of symbols.  */
7319   Elf_Internal_Sym *            funtab;         /* Sorted table of STT_FUNC symbols.  */
7320   unsigned long                 nfuns;          /* Number of entries in funtab.  */
7321   char *                        strtab;         /* The string table.  */
7322   unsigned long                 strtab_size;    /* Size of string table.  */
7323 };
7324
7325 static bfd_boolean
7326 dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7327 {
7328   struct ia64_unw_table_entry * tp;
7329   unsigned long j, nfuns;
7330   int in_body;
7331   bfd_boolean res = TRUE;
7332
7333   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7334   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7335     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7336       aux->funtab[nfuns++] = aux->symtab[j];
7337   aux->nfuns = nfuns;
7338   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7339
7340   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7341     {
7342       bfd_vma stamp;
7343       bfd_vma offset;
7344       const unsigned char * dp;
7345       const unsigned char * head;
7346       const unsigned char * end;
7347       const char * procname;
7348
7349       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7350                                aux->strtab_size, tp->start, &procname, &offset);
7351
7352       fputs ("\n<", stdout);
7353
7354       if (procname)
7355         {
7356           fputs (procname, stdout);
7357
7358           if (offset)
7359             printf ("+%lx", (unsigned long) offset);
7360         }
7361
7362       fputs (">: [", stdout);
7363       print_vma (tp->start.offset, PREFIX_HEX);
7364       fputc ('-', stdout);
7365       print_vma (tp->end.offset, PREFIX_HEX);
7366       printf ("], info at +0x%lx\n",
7367               (unsigned long) (tp->info.offset - aux->seg_base));
7368
7369       /* PR 17531: file: 86232b32.  */
7370       if (aux->info == NULL)
7371         continue;
7372
7373       /* PR 17531: file: 0997b4d1.  */
7374       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7375         {
7376           warn (_("Invalid offset %lx in table entry %ld\n"),
7377                 (long) tp->info.offset, (long) (tp - aux->table));
7378           res = FALSE;
7379           continue;
7380         }
7381
7382       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7383       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7384
7385       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7386               (unsigned) UNW_VER (stamp),
7387               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7388               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7389               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7390               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7391
7392       if (UNW_VER (stamp) != 1)
7393         {
7394           printf (_("\tUnknown version.\n"));
7395           continue;
7396         }
7397
7398       in_body = 0;
7399       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7400       /* PR 17531: file: 16ceda89.  */
7401       if (end > aux->info + aux->info_size)
7402         end = aux->info + aux->info_size;
7403       for (dp = head + 8; dp < end;)
7404         dp = unw_decode (dp, in_body, & in_body, end);
7405     }
7406
7407   free (aux->funtab);
7408
7409   return res;
7410 }
7411
7412 static bfd_boolean
7413 slurp_ia64_unwind_table (Filedata *                  filedata,
7414                          struct ia64_unw_aux_info *  aux,
7415                          Elf_Internal_Shdr *         sec)
7416 {
7417   unsigned long size, nrelas, i;
7418   Elf_Internal_Phdr * seg;
7419   struct ia64_unw_table_entry * tep;
7420   Elf_Internal_Shdr * relsec;
7421   Elf_Internal_Rela * rela;
7422   Elf_Internal_Rela * rp;
7423   unsigned char * table;
7424   unsigned char * tp;
7425   Elf_Internal_Sym * sym;
7426   const char * relname;
7427
7428   aux->table_len = 0;
7429
7430   /* First, find the starting address of the segment that includes
7431      this section: */
7432
7433   if (filedata->file_header.e_phnum)
7434     {
7435       if (! get_program_headers (filedata))
7436           return FALSE;
7437
7438       for (seg = filedata->program_headers;
7439            seg < filedata->program_headers + filedata->file_header.e_phnum;
7440            ++seg)
7441         {
7442           if (seg->p_type != PT_LOAD)
7443             continue;
7444
7445           if (sec->sh_addr >= seg->p_vaddr
7446               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7447             {
7448               aux->seg_base = seg->p_vaddr;
7449               break;
7450             }
7451         }
7452     }
7453
7454   /* Second, build the unwind table from the contents of the unwind section:  */
7455   size = sec->sh_size;
7456   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7457                                       _("unwind table"));
7458   if (!table)
7459     return FALSE;
7460
7461   aux->table_len = size / (3 * eh_addr_size);
7462   aux->table = (struct ia64_unw_table_entry *)
7463     xcmalloc (aux->table_len, sizeof (aux->table[0]));
7464   tep = aux->table;
7465
7466   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7467     {
7468       tep->start.section = SHN_UNDEF;
7469       tep->end.section   = SHN_UNDEF;
7470       tep->info.section  = SHN_UNDEF;
7471       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7472       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7473       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7474       tep->start.offset += aux->seg_base;
7475       tep->end.offset   += aux->seg_base;
7476       tep->info.offset  += aux->seg_base;
7477     }
7478   free (table);
7479
7480   /* Third, apply any relocations to the unwind table:  */
7481   for (relsec = filedata->section_headers;
7482        relsec < filedata->section_headers + filedata->file_header.e_shnum;
7483        ++relsec)
7484     {
7485       if (relsec->sh_type != SHT_RELA
7486           || relsec->sh_info >= filedata->file_header.e_shnum
7487           || filedata->section_headers + relsec->sh_info != sec)
7488         continue;
7489
7490       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7491                               & rela, & nrelas))
7492         {
7493           free (aux->table);
7494           aux->table = NULL;
7495           aux->table_len = 0;
7496           return FALSE;
7497         }
7498
7499       for (rp = rela; rp < rela + nrelas; ++rp)
7500         {
7501           relname = elf_ia64_reloc_type (get_reloc_type (filedata, rp->r_info));
7502           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7503
7504           /* PR 17531: file: 9fa67536.  */
7505           if (relname == NULL)
7506             {
7507               warn (_("Skipping unknown relocation type: %u\n"),
7508                     get_reloc_type (filedata, rp->r_info));
7509               continue;
7510             }
7511
7512           if (! const_strneq (relname, "R_IA64_SEGREL"))
7513             {
7514               warn (_("Skipping unexpected relocation type: %s\n"), relname);
7515               continue;
7516             }
7517
7518           i = rp->r_offset / (3 * eh_addr_size);
7519
7520           /* PR 17531: file: 5bc8d9bf.  */
7521           if (i >= aux->table_len)
7522             {
7523               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7524               continue;
7525             }
7526
7527           switch (rp->r_offset / eh_addr_size % 3)
7528             {
7529             case 0:
7530               aux->table[i].start.section = sym->st_shndx;
7531               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
7532               break;
7533             case 1:
7534               aux->table[i].end.section   = sym->st_shndx;
7535               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
7536               break;
7537             case 2:
7538               aux->table[i].info.section  = sym->st_shndx;
7539               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
7540               break;
7541             default:
7542               break;
7543             }
7544         }
7545
7546       free (rela);
7547     }
7548
7549   return TRUE;
7550 }
7551
7552 static bfd_boolean
7553 ia64_process_unwind (Filedata * filedata)
7554 {
7555   Elf_Internal_Shdr * sec;
7556   Elf_Internal_Shdr * unwsec = NULL;
7557   Elf_Internal_Shdr * strsec;
7558   unsigned long i, unwcount = 0, unwstart = 0;
7559   struct ia64_unw_aux_info aux;
7560   bfd_boolean res = TRUE;
7561
7562   memset (& aux, 0, sizeof (aux));
7563
7564   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7565     {
7566       if (sec->sh_type == SHT_SYMTAB
7567           && sec->sh_link < filedata->file_header.e_shnum)
7568         {
7569           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
7570
7571           strsec = filedata->section_headers + sec->sh_link;
7572           if (aux.strtab != NULL)
7573             {
7574               error (_("Multiple auxillary string tables encountered\n"));
7575               free (aux.strtab);
7576               res = FALSE;
7577             }
7578           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7579                                           1, strsec->sh_size,
7580                                           _("string table"));
7581           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7582         }
7583       else if (sec->sh_type == SHT_IA_64_UNWIND)
7584         unwcount++;
7585     }
7586
7587   if (!unwcount)
7588     printf (_("\nThere are no unwind sections in this file.\n"));
7589
7590   while (unwcount-- > 0)
7591     {
7592       char * suffix;
7593       size_t len, len2;
7594
7595       for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7596            i < filedata->file_header.e_shnum; ++i, ++sec)
7597         if (sec->sh_type == SHT_IA_64_UNWIND)
7598           {
7599             unwsec = sec;
7600             break;
7601           }
7602       /* We have already counted the number of SHT_IA64_UNWIND
7603          sections so the loop above should never fail.  */
7604       assert (unwsec != NULL);
7605
7606       unwstart = i + 1;
7607       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7608
7609       if ((unwsec->sh_flags & SHF_GROUP) != 0)
7610         {
7611           /* We need to find which section group it is in.  */
7612           struct group_list * g;
7613
7614           if (section_headers_groups == NULL
7615               || section_headers_groups [i] == NULL)
7616             i = filedata->file_header.e_shnum;
7617           else
7618             {
7619               g = section_headers_groups [i]->root;
7620
7621               for (; g != NULL; g = g->next)
7622                 {
7623                   sec = filedata->section_headers + g->section_index;
7624
7625                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7626                     break;
7627                 }
7628
7629               if (g == NULL)
7630                 i = filedata->file_header.e_shnum;
7631             }
7632         }
7633       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7634         {
7635           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
7636           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7637           suffix = SECTION_NAME (unwsec) + len;
7638           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7639                ++i, ++sec)
7640             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7641                 && streq (SECTION_NAME (sec) + len2, suffix))
7642               break;
7643         }
7644       else
7645         {
7646           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7647              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
7648           len = sizeof (ELF_STRING_ia64_unwind) - 1;
7649           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7650           suffix = "";
7651           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7652             suffix = SECTION_NAME (unwsec) + len;
7653           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7654                ++i, ++sec)
7655             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7656                 && streq (SECTION_NAME (sec) + len2, suffix))
7657               break;
7658         }
7659
7660       if (i == filedata->file_header.e_shnum)
7661         {
7662           printf (_("\nCould not find unwind info section for "));
7663
7664           if (filedata->string_table == NULL)
7665             printf ("%d", unwsec->sh_name);
7666           else
7667             printf ("'%s'", printable_section_name (filedata, unwsec));
7668         }
7669       else
7670         {
7671           aux.info_addr = sec->sh_addr;
7672           aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
7673                                                  sec->sh_size,
7674                                                  _("unwind info"));
7675           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7676
7677           printf (_("\nUnwind section "));
7678
7679           if (filedata->string_table == NULL)
7680             printf ("%d", unwsec->sh_name);
7681           else
7682             printf ("'%s'", printable_section_name (filedata, unwsec));
7683
7684           printf (_(" at offset 0x%lx contains %lu entries:\n"),
7685                   (unsigned long) unwsec->sh_offset,
7686                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7687
7688           if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
7689               && aux.table_len > 0)
7690             dump_ia64_unwind (filedata, & aux);
7691
7692           if (aux.table)
7693             free ((char *) aux.table);
7694           if (aux.info)
7695             free ((char *) aux.info);
7696           aux.table = NULL;
7697           aux.info = NULL;
7698         }
7699     }
7700
7701   if (aux.symtab)
7702     free (aux.symtab);
7703   if (aux.strtab)
7704     free ((char *) aux.strtab);
7705
7706   return res;
7707 }
7708
7709 struct hppa_unw_table_entry
7710 {
7711   struct absaddr start;
7712   struct absaddr end;
7713   unsigned int Cannot_unwind:1;                 /* 0 */
7714   unsigned int Millicode:1;                     /* 1 */
7715   unsigned int Millicode_save_sr0:1;            /* 2 */
7716   unsigned int Region_description:2;            /* 3..4 */
7717   unsigned int reserved1:1;                     /* 5 */
7718   unsigned int Entry_SR:1;                      /* 6 */
7719   unsigned int Entry_FR:4;     /* Number saved     7..10 */
7720   unsigned int Entry_GR:5;     /* Number saved     11..15 */
7721   unsigned int Args_stored:1;                   /* 16 */
7722   unsigned int Variable_Frame:1;                /* 17 */
7723   unsigned int Separate_Package_Body:1;         /* 18 */
7724   unsigned int Frame_Extension_Millicode:1;     /* 19 */
7725   unsigned int Stack_Overflow_Check:1;          /* 20 */
7726   unsigned int Two_Instruction_SP_Increment:1;  /* 21 */
7727   unsigned int Ada_Region:1;                    /* 22 */
7728   unsigned int cxx_info:1;                      /* 23 */
7729   unsigned int cxx_try_catch:1;                 /* 24 */
7730   unsigned int sched_entry_seq:1;               /* 25 */
7731   unsigned int reserved2:1;                     /* 26 */
7732   unsigned int Save_SP:1;                       /* 27 */
7733   unsigned int Save_RP:1;                       /* 28 */
7734   unsigned int Save_MRP_in_frame:1;             /* 29 */
7735   unsigned int extn_ptr_defined:1;              /* 30 */
7736   unsigned int Cleanup_defined:1;               /* 31 */
7737
7738   unsigned int MPE_XL_interrupt_marker:1;       /* 0 */
7739   unsigned int HP_UX_interrupt_marker:1;        /* 1 */
7740   unsigned int Large_frame:1;                   /* 2 */
7741   unsigned int Pseudo_SP_Set:1;                 /* 3 */
7742   unsigned int reserved4:1;                     /* 4 */
7743   unsigned int Total_frame_size:27;             /* 5..31 */
7744 };
7745
7746 struct hppa_unw_aux_info
7747 {
7748   struct hppa_unw_table_entry *  table;         /* Unwind table.  */
7749   unsigned long                  table_len;     /* Length of unwind table.  */
7750   bfd_vma                        seg_base;      /* Starting address of segment.  */
7751   Elf_Internal_Sym *             symtab;        /* The symbol table.  */
7752   unsigned long                  nsyms;         /* Number of symbols.  */
7753   Elf_Internal_Sym *             funtab;        /* Sorted table of STT_FUNC symbols.  */
7754   unsigned long                  nfuns;         /* Number of entries in funtab.  */
7755   char *                         strtab;        /* The string table.  */
7756   unsigned long                  strtab_size;   /* Size of string table.  */
7757 };
7758
7759 static bfd_boolean
7760 dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
7761 {
7762   struct hppa_unw_table_entry * tp;
7763   unsigned long j, nfuns;
7764   bfd_boolean res = TRUE;
7765
7766   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7767   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7768     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7769       aux->funtab[nfuns++] = aux->symtab[j];
7770   aux->nfuns = nfuns;
7771   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7772
7773   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7774     {
7775       bfd_vma offset;
7776       const char * procname;
7777
7778       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7779                                aux->strtab_size, tp->start, &procname,
7780                                &offset);
7781
7782       fputs ("\n<", stdout);
7783
7784       if (procname)
7785         {
7786           fputs (procname, stdout);
7787
7788           if (offset)
7789             printf ("+%lx", (unsigned long) offset);
7790         }
7791
7792       fputs (">: [", stdout);
7793       print_vma (tp->start.offset, PREFIX_HEX);
7794       fputc ('-', stdout);
7795       print_vma (tp->end.offset, PREFIX_HEX);
7796       printf ("]\n\t");
7797
7798 #define PF(_m) if (tp->_m) printf (#_m " ");
7799 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7800       PF(Cannot_unwind);
7801       PF(Millicode);
7802       PF(Millicode_save_sr0);
7803       /* PV(Region_description);  */
7804       PF(Entry_SR);
7805       PV(Entry_FR);
7806       PV(Entry_GR);
7807       PF(Args_stored);
7808       PF(Variable_Frame);
7809       PF(Separate_Package_Body);
7810       PF(Frame_Extension_Millicode);
7811       PF(Stack_Overflow_Check);
7812       PF(Two_Instruction_SP_Increment);
7813       PF(Ada_Region);
7814       PF(cxx_info);
7815       PF(cxx_try_catch);
7816       PF(sched_entry_seq);
7817       PF(Save_SP);
7818       PF(Save_RP);
7819       PF(Save_MRP_in_frame);
7820       PF(extn_ptr_defined);
7821       PF(Cleanup_defined);
7822       PF(MPE_XL_interrupt_marker);
7823       PF(HP_UX_interrupt_marker);
7824       PF(Large_frame);
7825       PF(Pseudo_SP_Set);
7826       PV(Total_frame_size);
7827 #undef PF
7828 #undef PV
7829     }
7830
7831   printf ("\n");
7832
7833   free (aux->funtab);
7834
7835   return res;
7836 }
7837
7838 static bfd_boolean
7839 slurp_hppa_unwind_table (Filedata *                  filedata,
7840                          struct hppa_unw_aux_info *  aux,
7841                          Elf_Internal_Shdr *         sec)
7842 {
7843   unsigned long size, unw_ent_size, nentries, nrelas, i;
7844   Elf_Internal_Phdr * seg;
7845   struct hppa_unw_table_entry * tep;
7846   Elf_Internal_Shdr * relsec;
7847   Elf_Internal_Rela * rela;
7848   Elf_Internal_Rela * rp;
7849   unsigned char * table;
7850   unsigned char * tp;
7851   Elf_Internal_Sym * sym;
7852   const char * relname;
7853
7854   /* First, find the starting address of the segment that includes
7855      this section.  */
7856   if (filedata->file_header.e_phnum)
7857     {
7858       if (! get_program_headers (filedata))
7859         return FALSE;
7860
7861       for (seg = filedata->program_headers;
7862            seg < filedata->program_headers + filedata->file_header.e_phnum;
7863            ++seg)
7864         {
7865           if (seg->p_type != PT_LOAD)
7866             continue;
7867
7868           if (sec->sh_addr >= seg->p_vaddr
7869               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7870             {
7871               aux->seg_base = seg->p_vaddr;
7872               break;
7873             }
7874         }
7875     }
7876
7877   /* Second, build the unwind table from the contents of the unwind
7878      section.  */
7879   size = sec->sh_size;
7880   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7881                                       _("unwind table"));
7882   if (!table)
7883     return FALSE;
7884
7885   unw_ent_size = 16;
7886   nentries = size / unw_ent_size;
7887   size = unw_ent_size * nentries;
7888
7889   tep = aux->table = (struct hppa_unw_table_entry *)
7890       xcmalloc (nentries, sizeof (aux->table[0]));
7891
7892   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7893     {
7894       unsigned int tmp1, tmp2;
7895
7896       tep->start.section = SHN_UNDEF;
7897       tep->end.section   = SHN_UNDEF;
7898
7899       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7900       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7901       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7902       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7903
7904       tep->start.offset += aux->seg_base;
7905       tep->end.offset   += aux->seg_base;
7906
7907       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7908       tep->Millicode = (tmp1 >> 30) & 0x1;
7909       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7910       tep->Region_description = (tmp1 >> 27) & 0x3;
7911       tep->reserved1 = (tmp1 >> 26) & 0x1;
7912       tep->Entry_SR = (tmp1 >> 25) & 0x1;
7913       tep->Entry_FR = (tmp1 >> 21) & 0xf;
7914       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7915       tep->Args_stored = (tmp1 >> 15) & 0x1;
7916       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7917       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7918       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7919       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7920       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7921       tep->Ada_Region = (tmp1 >> 9) & 0x1;
7922       tep->cxx_info = (tmp1 >> 8) & 0x1;
7923       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7924       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7925       tep->reserved2 = (tmp1 >> 5) & 0x1;
7926       tep->Save_SP = (tmp1 >> 4) & 0x1;
7927       tep->Save_RP = (tmp1 >> 3) & 0x1;
7928       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7929       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7930       tep->Cleanup_defined = tmp1 & 0x1;
7931
7932       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7933       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7934       tep->Large_frame = (tmp2 >> 29) & 0x1;
7935       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7936       tep->reserved4 = (tmp2 >> 27) & 0x1;
7937       tep->Total_frame_size = tmp2 & 0x7ffffff;
7938     }
7939   free (table);
7940
7941   /* Third, apply any relocations to the unwind table.  */
7942   for (relsec = filedata->section_headers;
7943        relsec < filedata->section_headers + filedata->file_header.e_shnum;
7944        ++relsec)
7945     {
7946       if (relsec->sh_type != SHT_RELA
7947           || relsec->sh_info >= filedata->file_header.e_shnum
7948           || filedata->section_headers + relsec->sh_info != sec)
7949         continue;
7950
7951       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7952                               & rela, & nrelas))
7953         return FALSE;
7954
7955       for (rp = rela; rp < rela + nrelas; ++rp)
7956         {
7957           relname = elf_hppa_reloc_type (get_reloc_type (filedata, rp->r_info));
7958           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7959
7960           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
7961           if (! const_strneq (relname, "R_PARISC_SEGREL"))
7962             {
7963               warn (_("Skipping unexpected relocation type %s\n"), relname);
7964               continue;
7965             }
7966
7967           i = rp->r_offset / unw_ent_size;
7968
7969           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
7970             {
7971             case 0:
7972               aux->table[i].start.section = sym->st_shndx;
7973               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
7974               break;
7975             case 1:
7976               aux->table[i].end.section   = sym->st_shndx;
7977               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
7978               break;
7979             default:
7980               break;
7981             }
7982         }
7983
7984       free (rela);
7985     }
7986
7987   aux->table_len = nentries;
7988
7989   return TRUE;
7990 }
7991
7992 static bfd_boolean
7993 hppa_process_unwind (Filedata * filedata)
7994 {
7995   struct hppa_unw_aux_info aux;
7996   Elf_Internal_Shdr * unwsec = NULL;
7997   Elf_Internal_Shdr * strsec;
7998   Elf_Internal_Shdr * sec;
7999   unsigned long i;
8000   bfd_boolean res = TRUE;
8001
8002   if (filedata->string_table == NULL)
8003     return FALSE;
8004
8005   memset (& aux, 0, sizeof (aux));
8006
8007   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8008     {
8009       if (sec->sh_type == SHT_SYMTAB
8010           && sec->sh_link < filedata->file_header.e_shnum)
8011         {
8012           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
8013
8014           strsec = filedata->section_headers + sec->sh_link;
8015           if (aux.strtab != NULL)
8016             {
8017               error (_("Multiple auxillary string tables encountered\n"));
8018               free (aux.strtab);
8019               res = FALSE;
8020             }
8021           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
8022                                           1, strsec->sh_size,
8023                                           _("string table"));
8024           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8025         }
8026       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8027         unwsec = sec;
8028     }
8029
8030   if (!unwsec)
8031     printf (_("\nThere are no unwind sections in this file.\n"));
8032
8033   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8034     {
8035       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8036         {
8037           unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size + 8);
8038
8039           printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8040                             "contains %lu entry:\n",
8041                             "\nUnwind section '%s' at offset 0x%lx "
8042                             "contains %lu entries:\n",
8043                             num_unwind),
8044                   printable_section_name (filedata, sec),
8045                   (unsigned long) sec->sh_offset,
8046                   num_unwind);
8047
8048           if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8049             res = FALSE;
8050
8051           if (aux.table_len > 0)
8052             {
8053               if (! dump_hppa_unwind (filedata, &aux))
8054                 res = FALSE;
8055             }
8056
8057           if (aux.table)
8058             free ((char *) aux.table);
8059           aux.table = NULL;
8060         }
8061     }
8062
8063   if (aux.symtab)
8064     free (aux.symtab);
8065   if (aux.strtab)
8066     free ((char *) aux.strtab);
8067
8068   return res;
8069 }
8070
8071 struct arm_section
8072 {
8073   unsigned char *      data;            /* The unwind data.  */
8074   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
8075   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
8076   unsigned long        nrelas;          /* The number of relocations.  */
8077   unsigned int         rel_type;        /* REL or RELA ?  */
8078   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
8079 };
8080
8081 struct arm_unw_aux_info
8082 {
8083   Filedata *          filedata;         /* The file containing the unwind sections.  */
8084   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
8085   unsigned long       nsyms;            /* Number of symbols.  */
8086   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
8087   unsigned long       nfuns;            /* Number of these symbols.  */
8088   char *              strtab;           /* The file's string table.  */
8089   unsigned long       strtab_size;      /* Size of string table.  */
8090 };
8091
8092 static const char *
8093 arm_print_vma_and_name (Filedata *                 filedata,
8094                         struct arm_unw_aux_info *  aux,
8095                         bfd_vma                    fn,
8096                         struct absaddr             addr)
8097 {
8098   const char *procname;
8099   bfd_vma sym_offset;
8100
8101   if (addr.section == SHN_UNDEF)
8102     addr.offset = fn;
8103
8104   find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8105                            aux->strtab_size, addr, &procname,
8106                            &sym_offset);
8107
8108   print_vma (fn, PREFIX_HEX);
8109
8110   if (procname)
8111     {
8112       fputs (" <", stdout);
8113       fputs (procname, stdout);
8114
8115       if (sym_offset)
8116         printf ("+0x%lx", (unsigned long) sym_offset);
8117       fputc ('>', stdout);
8118     }
8119
8120   return procname;
8121 }
8122
8123 static void
8124 arm_free_section (struct arm_section *arm_sec)
8125 {
8126   if (arm_sec->data != NULL)
8127     free (arm_sec->data);
8128
8129   if (arm_sec->rela != NULL)
8130     free (arm_sec->rela);
8131 }
8132
8133 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8134       cached section and install SEC instead.
8135    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8136       and return its valued in * WORDP, relocating if necessary.
8137    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8138       relocation's offset in ADDR.
8139    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8140       into the string table of the symbol associated with the reloc.  If no
8141       reloc was applied store -1 there.
8142    5) Return TRUE upon success, FALSE otherwise.  */
8143
8144 static bfd_boolean
8145 get_unwind_section_word (Filedata *                 filedata,
8146                          struct arm_unw_aux_info *  aux,
8147                          struct arm_section *       arm_sec,
8148                          Elf_Internal_Shdr *        sec,
8149                          bfd_vma                    word_offset,
8150                          unsigned int *             wordp,
8151                          struct absaddr *           addr,
8152                          bfd_vma *                  sym_name)
8153 {
8154   Elf_Internal_Rela *rp;
8155   Elf_Internal_Sym *sym;
8156   const char * relname;
8157   unsigned int word;
8158   bfd_boolean wrapped;
8159
8160   if (sec == NULL || arm_sec == NULL)
8161     return FALSE;
8162
8163   addr->section = SHN_UNDEF;
8164   addr->offset = 0;
8165
8166   if (sym_name != NULL)
8167     *sym_name = (bfd_vma) -1;
8168
8169   /* If necessary, update the section cache.  */
8170   if (sec != arm_sec->sec)
8171     {
8172       Elf_Internal_Shdr *relsec;
8173
8174       arm_free_section (arm_sec);
8175
8176       arm_sec->sec = sec;
8177       arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8178                                 sec->sh_size, _("unwind data"));
8179       arm_sec->rela = NULL;
8180       arm_sec->nrelas = 0;
8181
8182       for (relsec = filedata->section_headers;
8183            relsec < filedata->section_headers + filedata->file_header.e_shnum;
8184            ++relsec)
8185         {
8186           if (relsec->sh_info >= filedata->file_header.e_shnum
8187               || filedata->section_headers + relsec->sh_info != sec
8188               /* PR 15745: Check the section type as well.  */
8189               || (relsec->sh_type != SHT_REL
8190                   && relsec->sh_type != SHT_RELA))
8191             continue;
8192
8193           arm_sec->rel_type = relsec->sh_type;
8194           if (relsec->sh_type == SHT_REL)
8195             {
8196               if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8197                                      relsec->sh_size,
8198                                      & arm_sec->rela, & arm_sec->nrelas))
8199                 return FALSE;
8200             }
8201           else /* relsec->sh_type == SHT_RELA */
8202             {
8203               if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8204                                       relsec->sh_size,
8205                                       & arm_sec->rela, & arm_sec->nrelas))
8206                 return FALSE;
8207             }
8208           break;
8209         }
8210
8211       arm_sec->next_rela = arm_sec->rela;
8212     }
8213
8214   /* If there is no unwind data we can do nothing.  */
8215   if (arm_sec->data == NULL)
8216     return FALSE;
8217
8218   /* If the offset is invalid then fail.  */
8219   if (/* PR 21343 *//* PR 18879 */
8220       sec->sh_size < 4
8221       || word_offset > (sec->sh_size - 4)
8222       || ((bfd_signed_vma) word_offset) < 0)
8223     return FALSE;
8224
8225   /* Get the word at the required offset.  */
8226   word = byte_get (arm_sec->data + word_offset, 4);
8227
8228   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
8229   if (arm_sec->rela == NULL)
8230     {
8231       * wordp = word;
8232       return TRUE;
8233     }
8234
8235   /* Look through the relocs to find the one that applies to the provided offset.  */
8236   wrapped = FALSE;
8237   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8238     {
8239       bfd_vma prelval, offset;
8240
8241       if (rp->r_offset > word_offset && !wrapped)
8242         {
8243           rp = arm_sec->rela;
8244           wrapped = TRUE;
8245         }
8246       if (rp->r_offset > word_offset)
8247         break;
8248
8249       if (rp->r_offset & 3)
8250         {
8251           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8252                 (unsigned long) rp->r_offset);
8253           continue;
8254         }
8255
8256       if (rp->r_offset < word_offset)
8257         continue;
8258
8259       /* PR 17531: file: 027-161405-0.004  */
8260       if (aux->symtab == NULL)
8261         continue;
8262
8263       if (arm_sec->rel_type == SHT_REL)
8264         {
8265           offset = word & 0x7fffffff;
8266           if (offset & 0x40000000)
8267             offset |= ~ (bfd_vma) 0x7fffffff;
8268         }
8269       else if (arm_sec->rel_type == SHT_RELA)
8270         offset = rp->r_addend;
8271       else
8272         {
8273           error (_("Unknown section relocation type %d encountered\n"),
8274                  arm_sec->rel_type);
8275           break;
8276         }
8277
8278       /* PR 17531 file: 027-1241568-0.004.  */
8279       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8280         {
8281           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8282                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8283           break;
8284         }
8285
8286       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8287       offset += sym->st_value;
8288       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8289
8290       /* Check that we are processing the expected reloc type.  */
8291       if (filedata->file_header.e_machine == EM_ARM)
8292         {
8293           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8294           if (relname == NULL)
8295             {
8296               warn (_("Skipping unknown ARM relocation type: %d\n"),
8297                     (int) ELF32_R_TYPE (rp->r_info));
8298               continue;
8299             }
8300
8301           if (streq (relname, "R_ARM_NONE"))
8302               continue;
8303
8304           if (! streq (relname, "R_ARM_PREL31"))
8305             {
8306               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8307               continue;
8308             }
8309         }
8310       else if (filedata->file_header.e_machine == EM_TI_C6000)
8311         {
8312           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8313           if (relname == NULL)
8314             {
8315               warn (_("Skipping unknown C6000 relocation type: %d\n"),
8316                     (int) ELF32_R_TYPE (rp->r_info));
8317               continue;
8318             }
8319
8320           if (streq (relname, "R_C6000_NONE"))
8321             continue;
8322
8323           if (! streq (relname, "R_C6000_PREL31"))
8324             {
8325               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8326               continue;
8327             }
8328
8329           prelval >>= 1;
8330         }
8331       else
8332         {
8333           /* This function currently only supports ARM and TI unwinders.  */
8334           warn (_("Only TI and ARM unwinders are currently supported\n"));
8335           break;
8336         }
8337
8338       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8339       addr->section = sym->st_shndx;
8340       addr->offset = offset;
8341
8342       if (sym_name)
8343         * sym_name = sym->st_name;
8344       break;
8345     }
8346
8347   *wordp = word;
8348   arm_sec->next_rela = rp;
8349
8350   return TRUE;
8351 }
8352
8353 static const char *tic6x_unwind_regnames[16] =
8354 {
8355   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8356   "A14", "A13", "A12", "A11", "A10",
8357   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8358 };
8359
8360 static void
8361 decode_tic6x_unwind_regmask (unsigned int mask)
8362 {
8363   int i;
8364
8365   for (i = 12; mask; mask >>= 1, i--)
8366     {
8367       if (mask & 1)
8368         {
8369           fputs (tic6x_unwind_regnames[i], stdout);
8370           if (mask > 1)
8371             fputs (", ", stdout);
8372         }
8373     }
8374 }
8375
8376 #define ADVANCE                                                 \
8377   if (remaining == 0 && more_words)                             \
8378     {                                                           \
8379       data_offset += 4;                                         \
8380       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec,     \
8381                                      data_offset, & word, & addr, NULL))        \
8382         return FALSE;                                           \
8383       remaining = 4;                                            \
8384       more_words--;                                             \
8385     }                                                           \
8386
8387 #define GET_OP(OP)                      \
8388   ADVANCE;                              \
8389   if (remaining)                        \
8390     {                                   \
8391       remaining--;                      \
8392       (OP) = word >> 24;                \
8393       word <<= 8;                       \
8394     }                                   \
8395   else                                  \
8396     {                                   \
8397       printf (_("[Truncated opcode]\n"));       \
8398       return FALSE;                     \
8399     }                                   \
8400   printf ("0x%02x ", OP)
8401
8402 static bfd_boolean
8403 decode_arm_unwind_bytecode (Filedata *                 filedata,
8404                             struct arm_unw_aux_info *  aux,
8405                             unsigned int               word,
8406                             unsigned int               remaining,
8407                             unsigned int               more_words,
8408                             bfd_vma                    data_offset,
8409                             Elf_Internal_Shdr *        data_sec,
8410                             struct arm_section *       data_arm_sec)
8411 {
8412   struct absaddr addr;
8413   bfd_boolean res = TRUE;
8414
8415   /* Decode the unwinding instructions.  */
8416   while (1)
8417     {
8418       unsigned int op, op2;
8419
8420       ADVANCE;
8421       if (remaining == 0)
8422         break;
8423       remaining--;
8424       op = word >> 24;
8425       word <<= 8;
8426
8427       printf ("  0x%02x ", op);
8428
8429       if ((op & 0xc0) == 0x00)
8430         {
8431           int offset = ((op & 0x3f) << 2) + 4;
8432
8433           printf ("     vsp = vsp + %d", offset);
8434         }
8435       else if ((op & 0xc0) == 0x40)
8436         {
8437           int offset = ((op & 0x3f) << 2) + 4;
8438
8439           printf ("     vsp = vsp - %d", offset);
8440         }
8441       else if ((op & 0xf0) == 0x80)
8442         {
8443           GET_OP (op2);
8444           if (op == 0x80 && op2 == 0)
8445             printf (_("Refuse to unwind"));
8446           else
8447             {
8448               unsigned int mask = ((op & 0x0f) << 8) | op2;
8449               bfd_boolean first = TRUE;
8450               int i;
8451
8452               printf ("pop {");
8453               for (i = 0; i < 12; i++)
8454                 if (mask & (1 << i))
8455                   {
8456                     if (first)
8457                       first = FALSE;
8458                     else
8459                       printf (", ");
8460                     printf ("r%d", 4 + i);
8461                   }
8462               printf ("}");
8463             }
8464         }
8465       else if ((op & 0xf0) == 0x90)
8466         {
8467           if (op == 0x9d || op == 0x9f)
8468             printf (_("     [Reserved]"));
8469           else
8470             printf ("     vsp = r%d", op & 0x0f);
8471         }
8472       else if ((op & 0xf0) == 0xa0)
8473         {
8474           int end = 4 + (op & 0x07);
8475           bfd_boolean first = TRUE;
8476           int i;
8477
8478           printf ("     pop {");
8479           for (i = 4; i <= end; i++)
8480             {
8481               if (first)
8482                 first = FALSE;
8483               else
8484                 printf (", ");
8485               printf ("r%d", i);
8486             }
8487           if (op & 0x08)
8488             {
8489               if (!first)
8490                 printf (", ");
8491               printf ("r14");
8492             }
8493           printf ("}");
8494         }
8495       else if (op == 0xb0)
8496         printf (_("     finish"));
8497       else if (op == 0xb1)
8498         {
8499           GET_OP (op2);
8500           if (op2 == 0 || (op2 & 0xf0) != 0)
8501             printf (_("[Spare]"));
8502           else
8503             {
8504               unsigned int mask = op2 & 0x0f;
8505               bfd_boolean first = TRUE;
8506               int i;
8507
8508               printf ("pop {");
8509               for (i = 0; i < 12; i++)
8510                 if (mask & (1 << i))
8511                   {
8512                     if (first)
8513                       first = FALSE;
8514                     else
8515                       printf (", ");
8516                     printf ("r%d", i);
8517                   }
8518               printf ("}");
8519             }
8520         }
8521       else if (op == 0xb2)
8522         {
8523           unsigned char buf[9];
8524           unsigned int i, len;
8525           unsigned long offset;
8526
8527           for (i = 0; i < sizeof (buf); i++)
8528             {
8529               GET_OP (buf[i]);
8530               if ((buf[i] & 0x80) == 0)
8531                 break;
8532             }
8533           if (i == sizeof (buf))
8534             {
8535               error (_("corrupt change to vsp"));
8536               res = FALSE;
8537             }
8538           else
8539             {
8540               offset = read_uleb128 (buf, &len, buf + i + 1);
8541               assert (len == i + 1);
8542               offset = offset * 4 + 0x204;
8543               printf ("vsp = vsp + %ld", offset);
8544             }
8545         }
8546       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8547         {
8548           unsigned int first, last;
8549
8550           GET_OP (op2);
8551           first = op2 >> 4;
8552           last = op2 & 0x0f;
8553           if (op == 0xc8)
8554             first = first + 16;
8555           printf ("pop {D%d", first);
8556           if (last)
8557             printf ("-D%d", first + last);
8558           printf ("}");
8559         }
8560       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8561         {
8562           unsigned int count = op & 0x07;
8563
8564           printf ("pop {D8");
8565           if (count)
8566             printf ("-D%d", 8 + count);
8567           printf ("}");
8568         }
8569       else if (op >= 0xc0 && op <= 0xc5)
8570         {
8571           unsigned int count = op & 0x07;
8572
8573           printf ("     pop {wR10");
8574           if (count)
8575             printf ("-wR%d", 10 + count);
8576           printf ("}");
8577         }
8578       else if (op == 0xc6)
8579         {
8580           unsigned int first, last;
8581
8582           GET_OP (op2);
8583           first = op2 >> 4;
8584           last = op2 & 0x0f;
8585           printf ("pop {wR%d", first);
8586           if (last)
8587             printf ("-wR%d", first + last);
8588           printf ("}");
8589         }
8590       else if (op == 0xc7)
8591         {
8592           GET_OP (op2);
8593           if (op2 == 0 || (op2 & 0xf0) != 0)
8594             printf (_("[Spare]"));
8595           else
8596             {
8597               unsigned int mask = op2 & 0x0f;
8598               bfd_boolean first = TRUE;
8599               int i;
8600
8601               printf ("pop {");
8602               for (i = 0; i < 4; i++)
8603                 if (mask & (1 << i))
8604                   {
8605                     if (first)
8606                       first = FALSE;
8607                     else
8608                       printf (", ");
8609                     printf ("wCGR%d", i);
8610                   }
8611               printf ("}");
8612             }
8613         }
8614       else
8615         {
8616           printf (_("     [unsupported opcode]"));
8617           res = FALSE;
8618         }
8619
8620       printf ("\n");
8621     }
8622
8623   return res;
8624 }
8625
8626 static bfd_boolean
8627 decode_tic6x_unwind_bytecode (Filedata *                 filedata,
8628                               struct arm_unw_aux_info *  aux,
8629                               unsigned int               word,
8630                               unsigned int               remaining,
8631                               unsigned int               more_words,
8632                               bfd_vma                    data_offset,
8633                               Elf_Internal_Shdr *        data_sec,
8634                               struct arm_section *       data_arm_sec)
8635 {
8636   struct absaddr addr;
8637
8638   /* Decode the unwinding instructions.  */
8639   while (1)
8640     {
8641       unsigned int op, op2;
8642
8643       ADVANCE;
8644       if (remaining == 0)
8645         break;
8646       remaining--;
8647       op = word >> 24;
8648       word <<= 8;
8649
8650       printf ("  0x%02x ", op);
8651
8652       if ((op & 0xc0) == 0x00)
8653         {
8654           int offset = ((op & 0x3f) << 3) + 8;
8655           printf ("     sp = sp + %d", offset);
8656         }
8657       else if ((op & 0xc0) == 0x80)
8658         {
8659           GET_OP (op2);
8660           if (op == 0x80 && op2 == 0)
8661             printf (_("Refuse to unwind"));
8662           else
8663             {
8664               unsigned int mask = ((op & 0x1f) << 8) | op2;
8665               if (op & 0x20)
8666                 printf ("pop compact {");
8667               else
8668                 printf ("pop {");
8669
8670               decode_tic6x_unwind_regmask (mask);
8671               printf("}");
8672             }
8673         }
8674       else if ((op & 0xf0) == 0xc0)
8675         {
8676           unsigned int reg;
8677           unsigned int nregs;
8678           unsigned int i;
8679           const char *name;
8680           struct
8681           {
8682             unsigned int offset;
8683             unsigned int reg;
8684           } regpos[16];
8685
8686           /* Scan entire instruction first so that GET_OP output is not
8687              interleaved with disassembly.  */
8688           nregs = 0;
8689           for (i = 0; nregs < (op & 0xf); i++)
8690             {
8691               GET_OP (op2);
8692               reg = op2 >> 4;
8693               if (reg != 0xf)
8694                 {
8695                   regpos[nregs].offset = i * 2;
8696                   regpos[nregs].reg = reg;
8697                   nregs++;
8698                 }
8699
8700               reg = op2 & 0xf;
8701               if (reg != 0xf)
8702                 {
8703                   regpos[nregs].offset = i * 2 + 1;
8704                   regpos[nregs].reg = reg;
8705                   nregs++;
8706                 }
8707             }
8708
8709           printf (_("pop frame {"));
8710           reg = nregs - 1;
8711           for (i = i * 2; i > 0; i--)
8712             {
8713               if (regpos[reg].offset == i - 1)
8714                 {
8715                   name = tic6x_unwind_regnames[regpos[reg].reg];
8716                   if (reg > 0)
8717                     reg--;
8718                 }
8719               else
8720                 name = _("[pad]");
8721
8722               fputs (name, stdout);
8723               if (i > 1)
8724                 printf (", ");
8725             }
8726
8727           printf ("}");
8728         }
8729       else if (op == 0xd0)
8730         printf ("     MOV FP, SP");
8731       else if (op == 0xd1)
8732         printf ("     __c6xabi_pop_rts");
8733       else if (op == 0xd2)
8734         {
8735           unsigned char buf[9];
8736           unsigned int i, len;
8737           unsigned long offset;
8738
8739           for (i = 0; i < sizeof (buf); i++)
8740             {
8741               GET_OP (buf[i]);
8742               if ((buf[i] & 0x80) == 0)
8743                 break;
8744             }
8745           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8746           if (i == sizeof (buf))
8747             {
8748               warn (_("Corrupt stack pointer adjustment detected\n"));
8749               return FALSE;
8750             }
8751
8752           offset = read_uleb128 (buf, &len, buf + i + 1);
8753           assert (len == i + 1);
8754           offset = offset * 8 + 0x408;
8755           printf (_("sp = sp + %ld"), offset);
8756         }
8757       else if ((op & 0xf0) == 0xe0)
8758         {
8759           if ((op & 0x0f) == 7)
8760             printf ("     RETURN");
8761           else
8762             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8763         }
8764       else
8765         {
8766           printf (_("     [unsupported opcode]"));
8767         }
8768       putchar ('\n');
8769     }
8770
8771   return TRUE;
8772 }
8773
8774 static bfd_vma
8775 arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
8776 {
8777   bfd_vma offset;
8778
8779   offset = word & 0x7fffffff;
8780   if (offset & 0x40000000)
8781     offset |= ~ (bfd_vma) 0x7fffffff;
8782
8783   if (filedata->file_header.e_machine == EM_TI_C6000)
8784     offset <<= 1;
8785
8786   return offset + where;
8787 }
8788
8789 static bfd_boolean
8790 decode_arm_unwind (Filedata *                 filedata,
8791                    struct arm_unw_aux_info *  aux,
8792                    unsigned int               word,
8793                    unsigned int               remaining,
8794                    bfd_vma                    data_offset,
8795                    Elf_Internal_Shdr *        data_sec,
8796                    struct arm_section *       data_arm_sec)
8797 {
8798   int per_index;
8799   unsigned int more_words = 0;
8800   struct absaddr addr;
8801   bfd_vma sym_name = (bfd_vma) -1;
8802   bfd_boolean res = TRUE;
8803
8804   if (remaining == 0)
8805     {
8806       /* Fetch the first word.
8807          Note - when decoding an object file the address extracted
8808          here will always be 0.  So we also pass in the sym_name
8809          parameter so that we can find the symbol associated with
8810          the personality routine.  */
8811       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
8812                                      & word, & addr, & sym_name))
8813         return FALSE;
8814
8815       remaining = 4;
8816     }
8817
8818   if ((word & 0x80000000) == 0)
8819     {
8820       /* Expand prel31 for personality routine.  */
8821       bfd_vma fn;
8822       const char *procname;
8823
8824       fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
8825       printf (_("  Personality routine: "));
8826       if (fn == 0
8827           && addr.section == SHN_UNDEF && addr.offset == 0
8828           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8829         {
8830           procname = aux->strtab + sym_name;
8831           print_vma (fn, PREFIX_HEX);
8832           if (procname)
8833             {
8834               fputs (" <", stdout);
8835               fputs (procname, stdout);
8836               fputc ('>', stdout);
8837             }
8838         }
8839       else
8840         procname = arm_print_vma_and_name (filedata, aux, fn, addr);
8841       fputc ('\n', stdout);
8842
8843       /* The GCC personality routines use the standard compact
8844          encoding, starting with one byte giving the number of
8845          words.  */
8846       if (procname != NULL
8847           && (const_strneq (procname, "__gcc_personality_v0")
8848               || const_strneq (procname, "__gxx_personality_v0")
8849               || const_strneq (procname, "__gcj_personality_v0")
8850               || const_strneq (procname, "__gnu_objc_personality_v0")))
8851         {
8852           remaining = 0;
8853           more_words = 1;
8854           ADVANCE;
8855           if (!remaining)
8856             {
8857               printf (_("  [Truncated data]\n"));
8858               return FALSE;
8859             }
8860           more_words = word >> 24;
8861           word <<= 8;
8862           remaining--;
8863           per_index = -1;
8864         }
8865       else
8866         return TRUE;
8867     }
8868   else
8869     {
8870       /* ARM EHABI Section 6.3:
8871
8872          An exception-handling table entry for the compact model looks like:
8873
8874            31 30-28 27-24 23-0
8875            -- ----- ----- ----
8876             1   0   index Data for personalityRoutine[index]    */
8877
8878       if (filedata->file_header.e_machine == EM_ARM
8879           && (word & 0x70000000))
8880         {
8881           warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8882           res = FALSE;
8883         }
8884
8885       per_index = (word >> 24) & 0x7f;
8886       printf (_("  Compact model index: %d\n"), per_index);
8887       if (per_index == 0)
8888         {
8889           more_words = 0;
8890           word <<= 8;
8891           remaining--;
8892         }
8893       else if (per_index < 3)
8894         {
8895           more_words = (word >> 16) & 0xff;
8896           word <<= 16;
8897           remaining -= 2;
8898         }
8899     }
8900
8901   switch (filedata->file_header.e_machine)
8902     {
8903     case EM_ARM:
8904       if (per_index < 3)
8905         {
8906           if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
8907                                             data_offset, data_sec, data_arm_sec))
8908             res = FALSE;
8909         }
8910       else
8911         {
8912           warn (_("Unknown ARM compact model index encountered\n"));
8913           printf (_("  [reserved]\n"));
8914           res = FALSE;
8915         }
8916       break;
8917
8918     case EM_TI_C6000:
8919       if (per_index < 3)
8920         {
8921           if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
8922                                               data_offset, data_sec, data_arm_sec))
8923             res = FALSE;
8924         }
8925       else if (per_index < 5)
8926         {
8927           if (((word >> 17) & 0x7f) == 0x7f)
8928             printf (_("  Restore stack from frame pointer\n"));
8929           else
8930             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
8931           printf (_("  Registers restored: "));
8932           if (per_index == 4)
8933             printf (" (compact) ");
8934           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8935           putchar ('\n');
8936           printf (_("  Return register: %s\n"),
8937                   tic6x_unwind_regnames[word & 0xf]);
8938         }
8939       else
8940         printf (_("  [reserved (%d)]\n"), per_index);
8941       break;
8942
8943     default:
8944       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8945              filedata->file_header.e_machine);
8946       res = FALSE;
8947     }
8948
8949   /* Decode the descriptors.  Not implemented.  */
8950
8951   return res;
8952 }
8953
8954 static bfd_boolean
8955 dump_arm_unwind (Filedata *                 filedata,
8956                  struct arm_unw_aux_info *  aux,
8957                  Elf_Internal_Shdr *        exidx_sec)
8958 {
8959   struct arm_section exidx_arm_sec, extab_arm_sec;
8960   unsigned int i, exidx_len;
8961   unsigned long j, nfuns;
8962   bfd_boolean res = TRUE;
8963
8964   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8965   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8966   exidx_len = exidx_sec->sh_size / 8;
8967
8968   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8969   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8970     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8971       aux->funtab[nfuns++] = aux->symtab[j];
8972   aux->nfuns = nfuns;
8973   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8974
8975   for (i = 0; i < exidx_len; i++)
8976     {
8977       unsigned int exidx_fn, exidx_entry;
8978       struct absaddr fn_addr, entry_addr;
8979       bfd_vma fn;
8980
8981       fputc ('\n', stdout);
8982
8983       if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
8984                                      8 * i, & exidx_fn, & fn_addr, NULL)
8985           || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
8986                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
8987         {
8988           free (aux->funtab);
8989           arm_free_section (& exidx_arm_sec);
8990           arm_free_section (& extab_arm_sec);
8991           return FALSE;
8992         }
8993
8994       /* ARM EHABI, Section 5:
8995          An index table entry consists of 2 words.
8996          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
8997       if (exidx_fn & 0x80000000)
8998         {
8999           warn (_("corrupt index table entry: %x\n"), exidx_fn);
9000           res = FALSE;
9001         }
9002
9003       fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9004
9005       arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9006       fputs (": ", stdout);
9007
9008       if (exidx_entry == 1)
9009         {
9010           print_vma (exidx_entry, PREFIX_HEX);
9011           fputs (" [cantunwind]\n", stdout);
9012         }
9013       else if (exidx_entry & 0x80000000)
9014         {
9015           print_vma (exidx_entry, PREFIX_HEX);
9016           fputc ('\n', stdout);
9017           decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9018         }
9019       else
9020         {
9021           bfd_vma table, table_offset = 0;
9022           Elf_Internal_Shdr *table_sec;
9023
9024           fputs ("@", stdout);
9025           table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9026           print_vma (table, PREFIX_HEX);
9027           printf ("\n");
9028
9029           /* Locate the matching .ARM.extab.  */
9030           if (entry_addr.section != SHN_UNDEF
9031               && entry_addr.section < filedata->file_header.e_shnum)
9032             {
9033               table_sec = filedata->section_headers + entry_addr.section;
9034               table_offset = entry_addr.offset;
9035               /* PR 18879 */
9036               if (table_offset > table_sec->sh_size
9037                   || ((bfd_signed_vma) table_offset) < 0)
9038                 {
9039                   warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9040                         (unsigned long) table_offset,
9041                         printable_section_name (filedata, table_sec));
9042                   res = FALSE;
9043                   continue;
9044                 }
9045             }
9046           else
9047             {
9048               table_sec = find_section_by_address (filedata, table);
9049               if (table_sec != NULL)
9050                 table_offset = table - table_sec->sh_addr;
9051             }
9052
9053           if (table_sec == NULL)
9054             {
9055               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9056                     (unsigned long) table);
9057               res = FALSE;
9058               continue;
9059             }
9060
9061           if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9062                                    &extab_arm_sec))
9063             res = FALSE;
9064         }
9065     }
9066
9067   printf ("\n");
9068
9069   free (aux->funtab);
9070   arm_free_section (&exidx_arm_sec);
9071   arm_free_section (&extab_arm_sec);
9072
9073   return res;
9074 }
9075
9076 /* Used for both ARM and C6X unwinding tables.  */
9077
9078 static bfd_boolean
9079 arm_process_unwind (Filedata * filedata)
9080 {
9081   struct arm_unw_aux_info aux;
9082   Elf_Internal_Shdr *unwsec = NULL;
9083   Elf_Internal_Shdr *strsec;
9084   Elf_Internal_Shdr *sec;
9085   unsigned long i;
9086   unsigned int sec_type;
9087   bfd_boolean res = TRUE;
9088
9089   switch (filedata->file_header.e_machine)
9090     {
9091     case EM_ARM:
9092       sec_type = SHT_ARM_EXIDX;
9093       break;
9094
9095     case EM_TI_C6000:
9096       sec_type = SHT_C6000_UNWIND;
9097       break;
9098
9099     default:
9100       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9101              filedata->file_header.e_machine);
9102       return FALSE;
9103     }
9104
9105   if (filedata->string_table == NULL)
9106     return FALSE;
9107
9108   memset (& aux, 0, sizeof (aux));
9109   aux.filedata = filedata;
9110
9111   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9112     {
9113       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < filedata->file_header.e_shnum)
9114         {
9115           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
9116
9117           strsec = filedata->section_headers + sec->sh_link;
9118
9119           /* PR binutils/17531 file: 011-12666-0.004.  */
9120           if (aux.strtab != NULL)
9121             {
9122               error (_("Multiple string tables found in file.\n"));
9123               free (aux.strtab);
9124               res = FALSE;
9125             }
9126           aux.strtab = get_data (NULL, filedata, strsec->sh_offset,
9127                                  1, strsec->sh_size, _("string table"));
9128           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9129         }
9130       else if (sec->sh_type == sec_type)
9131         unwsec = sec;
9132     }
9133
9134   if (unwsec == NULL)
9135     printf (_("\nThere are no unwind sections in this file.\n"));
9136   else
9137     for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9138       {
9139         if (sec->sh_type == sec_type)
9140           {
9141             unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9142             printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9143                               "contains %lu entry:\n",
9144                               "\nUnwind section '%s' at offset 0x%lx "
9145                               "contains %lu entries:\n",
9146                               num_unwind),
9147                     printable_section_name (filedata, sec),
9148                     (unsigned long) sec->sh_offset,
9149                     num_unwind);
9150
9151             if (! dump_arm_unwind (filedata, &aux, sec))
9152               res = FALSE;
9153           }
9154       }
9155
9156   if (aux.symtab)
9157     free (aux.symtab);
9158   if (aux.strtab)
9159     free ((char *) aux.strtab);
9160
9161   return res;
9162 }
9163
9164 static bfd_boolean
9165 process_unwind (Filedata * filedata)
9166 {
9167   struct unwind_handler
9168   {
9169     unsigned int machtype;
9170     bfd_boolean (* handler)(Filedata *);
9171   } handlers[] =
9172   {
9173     { EM_ARM, arm_process_unwind },
9174     { EM_IA_64, ia64_process_unwind },
9175     { EM_PARISC, hppa_process_unwind },
9176     { EM_TI_C6000, arm_process_unwind },
9177     { 0, NULL }
9178   };
9179   int i;
9180
9181   if (!do_unwind)
9182     return TRUE;
9183
9184   for (i = 0; handlers[i].handler != NULL; i++)
9185     if (filedata->file_header.e_machine == handlers[i].machtype)
9186       return handlers[i].handler (filedata);
9187
9188   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9189           get_machine_name (filedata->file_header.e_machine));
9190   return TRUE;
9191 }
9192
9193 static void
9194 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9195 {
9196   switch (entry->d_tag)
9197     {
9198     case DT_MIPS_FLAGS:
9199       if (entry->d_un.d_val == 0)
9200         printf (_("NONE"));
9201       else
9202         {
9203           static const char * opts[] =
9204           {
9205             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9206             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9207             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9208             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9209             "RLD_ORDER_SAFE"
9210           };
9211           unsigned int cnt;
9212           bfd_boolean first = TRUE;
9213
9214           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9215             if (entry->d_un.d_val & (1 << cnt))
9216               {
9217                 printf ("%s%s", first ? "" : " ", opts[cnt]);
9218                 first = FALSE;
9219               }
9220         }
9221       break;
9222
9223     case DT_MIPS_IVERSION:
9224       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9225         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9226       else
9227         {
9228           char buf[40];
9229           sprintf_vma (buf, entry->d_un.d_ptr);
9230           /* Note: coded this way so that there is a single string for translation.  */
9231           printf (_("<corrupt: %s>"), buf);
9232         }
9233       break;
9234
9235     case DT_MIPS_TIME_STAMP:
9236       {
9237         char timebuf[128];
9238         struct tm * tmp;
9239         time_t atime = entry->d_un.d_val;
9240
9241         tmp = gmtime (&atime);
9242         /* PR 17531: file: 6accc532.  */
9243         if (tmp == NULL)
9244           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9245         else
9246           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9247                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9248                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9249         printf (_("Time Stamp: %s"), timebuf);
9250       }
9251       break;
9252
9253     case DT_MIPS_RLD_VERSION:
9254     case DT_MIPS_LOCAL_GOTNO:
9255     case DT_MIPS_CONFLICTNO:
9256     case DT_MIPS_LIBLISTNO:
9257     case DT_MIPS_SYMTABNO:
9258     case DT_MIPS_UNREFEXTNO:
9259     case DT_MIPS_HIPAGENO:
9260     case DT_MIPS_DELTA_CLASS_NO:
9261     case DT_MIPS_DELTA_INSTANCE_NO:
9262     case DT_MIPS_DELTA_RELOC_NO:
9263     case DT_MIPS_DELTA_SYM_NO:
9264     case DT_MIPS_DELTA_CLASSSYM_NO:
9265     case DT_MIPS_COMPACT_SIZE:
9266       print_vma (entry->d_un.d_val, DEC);
9267       break;
9268
9269     default:
9270       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9271     }
9272     putchar ('\n');
9273 }
9274
9275 static void
9276 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9277 {
9278   switch (entry->d_tag)
9279     {
9280     case DT_HP_DLD_FLAGS:
9281       {
9282         static struct
9283         {
9284           long int bit;
9285           const char * str;
9286         }
9287         flags[] =
9288         {
9289           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9290           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9291           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9292           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9293           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9294           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9295           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9296           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9297           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9298           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9299           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9300           { DT_HP_GST, "HP_GST" },
9301           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9302           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9303           { DT_HP_NODELETE, "HP_NODELETE" },
9304           { DT_HP_GROUP, "HP_GROUP" },
9305           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9306         };
9307         bfd_boolean first = TRUE;
9308         size_t cnt;
9309         bfd_vma val = entry->d_un.d_val;
9310
9311         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9312           if (val & flags[cnt].bit)
9313             {
9314               if (! first)
9315                 putchar (' ');
9316               fputs (flags[cnt].str, stdout);
9317               first = FALSE;
9318               val ^= flags[cnt].bit;
9319             }
9320
9321         if (val != 0 || first)
9322           {
9323             if (! first)
9324               putchar (' ');
9325             print_vma (val, HEX);
9326           }
9327       }
9328       break;
9329
9330     default:
9331       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9332       break;
9333     }
9334   putchar ('\n');
9335 }
9336
9337 #ifdef BFD64
9338
9339 /* VMS vs Unix time offset and factor.  */
9340
9341 #define VMS_EPOCH_OFFSET 35067168000000000LL
9342 #define VMS_GRANULARITY_FACTOR 10000000
9343
9344 /* Display a VMS time in a human readable format.  */
9345
9346 static void
9347 print_vms_time (bfd_int64_t vmstime)
9348 {
9349   struct tm *tm;
9350   time_t unxtime;
9351
9352   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9353   tm = gmtime (&unxtime);
9354   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9355           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9356           tm->tm_hour, tm->tm_min, tm->tm_sec);
9357 }
9358 #endif /* BFD64 */
9359
9360 static void
9361 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9362 {
9363   switch (entry->d_tag)
9364     {
9365     case DT_IA_64_PLT_RESERVE:
9366       /* First 3 slots reserved.  */
9367       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9368       printf (" -- ");
9369       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9370       break;
9371
9372     case DT_IA_64_VMS_LINKTIME:
9373 #ifdef BFD64
9374       print_vms_time (entry->d_un.d_val);
9375 #endif
9376       break;
9377
9378     case DT_IA_64_VMS_LNKFLAGS:
9379       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9380       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9381         printf (" CALL_DEBUG");
9382       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9383         printf (" NOP0BUFS");
9384       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9385         printf (" P0IMAGE");
9386       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9387         printf (" MKTHREADS");
9388       if (entry->d_un.d_val & VMS_LF_UPCALLS)
9389         printf (" UPCALLS");
9390       if (entry->d_un.d_val & VMS_LF_IMGSTA)
9391         printf (" IMGSTA");
9392       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9393         printf (" INITIALIZE");
9394       if (entry->d_un.d_val & VMS_LF_MAIN)
9395         printf (" MAIN");
9396       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9397         printf (" EXE_INIT");
9398       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9399         printf (" TBK_IN_IMG");
9400       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9401         printf (" DBG_IN_IMG");
9402       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9403         printf (" TBK_IN_DSF");
9404       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9405         printf (" DBG_IN_DSF");
9406       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9407         printf (" SIGNATURES");
9408       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9409         printf (" REL_SEG_OFF");
9410       break;
9411
9412     default:
9413       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9414       break;
9415     }
9416   putchar ('\n');
9417 }
9418
9419 static bfd_boolean
9420 get_32bit_dynamic_section (Filedata * filedata)
9421 {
9422   Elf32_External_Dyn * edyn;
9423   Elf32_External_Dyn * ext;
9424   Elf_Internal_Dyn * entry;
9425
9426   edyn = (Elf32_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9427                                           dynamic_size, _("dynamic section"));
9428   if (!edyn)
9429     return FALSE;
9430
9431   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9432      might not have the luxury of section headers.  Look for the DT_NULL
9433      terminator to determine the number of entries.  */
9434   for (ext = edyn, dynamic_nent = 0;
9435        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9436        ext++)
9437     {
9438       dynamic_nent++;
9439       if (BYTE_GET (ext->d_tag) == DT_NULL)
9440         break;
9441     }
9442
9443   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9444                                                   sizeof (* entry));
9445   if (dynamic_section == NULL)
9446     {
9447       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9448              (unsigned long) dynamic_nent);
9449       free (edyn);
9450       return FALSE;
9451     }
9452
9453   for (ext = edyn, entry = dynamic_section;
9454        entry < dynamic_section + dynamic_nent;
9455        ext++, entry++)
9456     {
9457       entry->d_tag      = BYTE_GET (ext->d_tag);
9458       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9459     }
9460
9461   free (edyn);
9462
9463   return TRUE;
9464 }
9465
9466 static bfd_boolean
9467 get_64bit_dynamic_section (Filedata * filedata)
9468 {
9469   Elf64_External_Dyn * edyn;
9470   Elf64_External_Dyn * ext;
9471   Elf_Internal_Dyn * entry;
9472
9473   /* Read in the data.  */
9474   edyn = (Elf64_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9475                                           dynamic_size, _("dynamic section"));
9476   if (!edyn)
9477     return FALSE;
9478
9479   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9480      might not have the luxury of section headers.  Look for the DT_NULL
9481      terminator to determine the number of entries.  */
9482   for (ext = edyn, dynamic_nent = 0;
9483        /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer.  */
9484        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9485        ext++)
9486     {
9487       dynamic_nent++;
9488       if (BYTE_GET (ext->d_tag) == DT_NULL)
9489         break;
9490     }
9491
9492   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9493                                                   sizeof (* entry));
9494   if (dynamic_section == NULL)
9495     {
9496       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9497              (unsigned long) dynamic_nent);
9498       free (edyn);
9499       return FALSE;
9500     }
9501
9502   /* Convert from external to internal formats.  */
9503   for (ext = edyn, entry = dynamic_section;
9504        entry < dynamic_section + dynamic_nent;
9505        ext++, entry++)
9506     {
9507       entry->d_tag      = BYTE_GET (ext->d_tag);
9508       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9509     }
9510
9511   free (edyn);
9512
9513   return TRUE;
9514 }
9515
9516 static void
9517 print_dynamic_flags (bfd_vma flags)
9518 {
9519   bfd_boolean first = TRUE;
9520
9521   while (flags)
9522     {
9523       bfd_vma flag;
9524
9525       flag = flags & - flags;
9526       flags &= ~ flag;
9527
9528       if (first)
9529         first = FALSE;
9530       else
9531         putc (' ', stdout);
9532
9533       switch (flag)
9534         {
9535         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
9536         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
9537         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
9538         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
9539         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
9540         default:                fputs (_("unknown"), stdout); break;
9541         }
9542     }
9543   puts ("");
9544 }
9545
9546 /* Parse and display the contents of the dynamic section.  */
9547
9548 static bfd_boolean
9549 process_dynamic_section (Filedata * filedata)
9550 {
9551   Elf_Internal_Dyn * entry;
9552
9553   if (dynamic_size == 0)
9554     {
9555       if (do_dynamic)
9556         printf (_("\nThere is no dynamic section in this file.\n"));
9557
9558       return TRUE;
9559     }
9560
9561   if (is_32bit_elf)
9562     {
9563       if (! get_32bit_dynamic_section (filedata))
9564         return FALSE;
9565     }
9566   else
9567     {
9568       if (! get_64bit_dynamic_section (filedata))
9569         return FALSE;
9570     }
9571
9572   /* Find the appropriate symbol table.  */
9573   if (dynamic_symbols == NULL)
9574     {
9575       for (entry = dynamic_section;
9576            entry < dynamic_section + dynamic_nent;
9577            ++entry)
9578         {
9579           Elf_Internal_Shdr section;
9580
9581           if (entry->d_tag != DT_SYMTAB)
9582             continue;
9583
9584           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9585
9586           /* Since we do not know how big the symbol table is,
9587              we default to reading in the entire file (!) and
9588              processing that.  This is overkill, I know, but it
9589              should work.  */
9590           section.sh_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9591           if ((bfd_size_type) section.sh_offset > filedata->file_size)
9592             {
9593               /* See PR 21379 for a reproducer.  */
9594               error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9595               return FALSE;
9596             }
9597
9598           if (archive_file_offset != 0)
9599             section.sh_size = archive_file_size - section.sh_offset;
9600           else
9601             section.sh_size = filedata->file_size - section.sh_offset;
9602
9603           if (is_32bit_elf)
9604             section.sh_entsize = sizeof (Elf32_External_Sym);
9605           else
9606             section.sh_entsize = sizeof (Elf64_External_Sym);
9607           section.sh_name = filedata->string_table_length;
9608
9609           dynamic_symbols = GET_ELF_SYMBOLS (filedata, &section, & num_dynamic_syms);
9610           if (num_dynamic_syms < 1)
9611             {
9612               error (_("Unable to determine the number of symbols to load\n"));
9613               continue;
9614             }
9615         }
9616     }
9617
9618   /* Similarly find a string table.  */
9619   if (dynamic_strings == NULL)
9620     {
9621       for (entry = dynamic_section;
9622            entry < dynamic_section + dynamic_nent;
9623            ++entry)
9624         {
9625           unsigned long offset;
9626           long str_tab_len;
9627
9628           if (entry->d_tag != DT_STRTAB)
9629             continue;
9630
9631           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9632
9633           /* Since we do not know how big the string table is,
9634              we default to reading in the entire file (!) and
9635              processing that.  This is overkill, I know, but it
9636              should work.  */
9637
9638           offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9639
9640           if (archive_file_offset != 0)
9641             str_tab_len = archive_file_size - offset;
9642           else
9643             str_tab_len = filedata->file_size;
9644
9645           if (str_tab_len < 1)
9646             {
9647               error
9648                 (_("Unable to determine the length of the dynamic string table\n"));
9649               continue;
9650             }
9651
9652           dynamic_strings = (char *) get_data (NULL, filedata, offset, 1,
9653                                                str_tab_len,
9654                                                _("dynamic string table"));
9655           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9656           break;
9657         }
9658     }
9659
9660   /* And find the syminfo section if available.  */
9661   if (dynamic_syminfo == NULL)
9662     {
9663       unsigned long syminsz = 0;
9664
9665       for (entry = dynamic_section;
9666            entry < dynamic_section + dynamic_nent;
9667            ++entry)
9668         {
9669           if (entry->d_tag == DT_SYMINENT)
9670             {
9671               /* Note: these braces are necessary to avoid a syntax
9672                  error from the SunOS4 C compiler.  */
9673               /* PR binutils/17531: A corrupt file can trigger this test.
9674                  So do not use an assert, instead generate an error message.  */
9675               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9676                 error (_("Bad value (%d) for SYMINENT entry\n"),
9677                        (int) entry->d_un.d_val);
9678             }
9679           else if (entry->d_tag == DT_SYMINSZ)
9680             syminsz = entry->d_un.d_val;
9681           else if (entry->d_tag == DT_SYMINFO)
9682             dynamic_syminfo_offset = offset_from_vma (filedata, entry->d_un.d_val,
9683                                                       syminsz);
9684         }
9685
9686       if (dynamic_syminfo_offset != 0 && syminsz != 0)
9687         {
9688           Elf_External_Syminfo * extsyminfo;
9689           Elf_External_Syminfo * extsym;
9690           Elf_Internal_Syminfo * syminfo;
9691
9692           /* There is a syminfo section.  Read the data.  */
9693           extsyminfo = (Elf_External_Syminfo *)
9694               get_data (NULL, filedata, dynamic_syminfo_offset, 1, syminsz,
9695                         _("symbol information"));
9696           if (!extsyminfo)
9697             return FALSE;
9698
9699           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9700           if (dynamic_syminfo == NULL)
9701             {
9702               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9703                      (unsigned long) syminsz);
9704               return FALSE;
9705             }
9706
9707           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9708           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9709                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9710                ++syminfo, ++extsym)
9711             {
9712               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9713               syminfo->si_flags = BYTE_GET (extsym->si_flags);
9714             }
9715
9716           free (extsyminfo);
9717         }
9718     }
9719
9720   if (do_dynamic && dynamic_addr)
9721     printf (ngettext ("\nDynamic section at offset 0x%lx "
9722                       "contains %lu entry:\n",
9723                       "\nDynamic section at offset 0x%lx "
9724                       "contains %lu entries:\n",
9725                       dynamic_nent),
9726             dynamic_addr, (unsigned long) dynamic_nent);
9727   if (do_dynamic)
9728     printf (_("  Tag        Type                         Name/Value\n"));
9729
9730   for (entry = dynamic_section;
9731        entry < dynamic_section + dynamic_nent;
9732        entry++)
9733     {
9734       if (do_dynamic)
9735         {
9736           const char * dtype;
9737
9738           putchar (' ');
9739           print_vma (entry->d_tag, FULL_HEX);
9740           dtype = get_dynamic_type (filedata, entry->d_tag);
9741           printf (" (%s)%*s", dtype,
9742                   ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9743         }
9744
9745       switch (entry->d_tag)
9746         {
9747         case DT_FLAGS:
9748           if (do_dynamic)
9749             print_dynamic_flags (entry->d_un.d_val);
9750           break;
9751
9752         case DT_AUXILIARY:
9753         case DT_FILTER:
9754         case DT_CONFIG:
9755         case DT_DEPAUDIT:
9756         case DT_AUDIT:
9757           if (do_dynamic)
9758             {
9759               switch (entry->d_tag)
9760                 {
9761                 case DT_AUXILIARY:
9762                   printf (_("Auxiliary library"));
9763                   break;
9764
9765                 case DT_FILTER:
9766                   printf (_("Filter library"));
9767                   break;
9768
9769                 case DT_CONFIG:
9770                   printf (_("Configuration file"));
9771                   break;
9772
9773                 case DT_DEPAUDIT:
9774                   printf (_("Dependency audit library"));
9775                   break;
9776
9777                 case DT_AUDIT:
9778                   printf (_("Audit library"));
9779                   break;
9780                 }
9781
9782               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9783                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9784               else
9785                 {
9786                   printf (": ");
9787                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9788                   putchar ('\n');
9789                 }
9790             }
9791           break;
9792
9793         case DT_FEATURE:
9794           if (do_dynamic)
9795             {
9796               printf (_("Flags:"));
9797
9798               if (entry->d_un.d_val == 0)
9799                 printf (_(" None\n"));
9800               else
9801                 {
9802                   unsigned long int val = entry->d_un.d_val;
9803
9804                   if (val & DTF_1_PARINIT)
9805                     {
9806                       printf (" PARINIT");
9807                       val ^= DTF_1_PARINIT;
9808                     }
9809                   if (val & DTF_1_CONFEXP)
9810                     {
9811                       printf (" CONFEXP");
9812                       val ^= DTF_1_CONFEXP;
9813                     }
9814                   if (val != 0)
9815                     printf (" %lx", val);
9816                   puts ("");
9817                 }
9818             }
9819           break;
9820
9821         case DT_POSFLAG_1:
9822           if (do_dynamic)
9823             {
9824               printf (_("Flags:"));
9825
9826               if (entry->d_un.d_val == 0)
9827                 printf (_(" None\n"));
9828               else
9829                 {
9830                   unsigned long int val = entry->d_un.d_val;
9831
9832                   if (val & DF_P1_LAZYLOAD)
9833                     {
9834                       printf (" LAZYLOAD");
9835                       val ^= DF_P1_LAZYLOAD;
9836                     }
9837                   if (val & DF_P1_GROUPPERM)
9838                     {
9839                       printf (" GROUPPERM");
9840                       val ^= DF_P1_GROUPPERM;
9841                     }
9842                   if (val != 0)
9843                     printf (" %lx", val);
9844                   puts ("");
9845                 }
9846             }
9847           break;
9848
9849         case DT_FLAGS_1:
9850           if (do_dynamic)
9851             {
9852               printf (_("Flags:"));
9853               if (entry->d_un.d_val == 0)
9854                 printf (_(" None\n"));
9855               else
9856                 {
9857                   unsigned long int val = entry->d_un.d_val;
9858
9859                   if (val & DF_1_NOW)
9860                     {
9861                       printf (" NOW");
9862                       val ^= DF_1_NOW;
9863                     }
9864                   if (val & DF_1_GLOBAL)
9865                     {
9866                       printf (" GLOBAL");
9867                       val ^= DF_1_GLOBAL;
9868                     }
9869                   if (val & DF_1_GROUP)
9870                     {
9871                       printf (" GROUP");
9872                       val ^= DF_1_GROUP;
9873                     }
9874                   if (val & DF_1_NODELETE)
9875                     {
9876                       printf (" NODELETE");
9877                       val ^= DF_1_NODELETE;
9878                     }
9879                   if (val & DF_1_LOADFLTR)
9880                     {
9881                       printf (" LOADFLTR");
9882                       val ^= DF_1_LOADFLTR;
9883                     }
9884                   if (val & DF_1_INITFIRST)
9885                     {
9886                       printf (" INITFIRST");
9887                       val ^= DF_1_INITFIRST;
9888                     }
9889                   if (val & DF_1_NOOPEN)
9890                     {
9891                       printf (" NOOPEN");
9892                       val ^= DF_1_NOOPEN;
9893                     }
9894                   if (val & DF_1_ORIGIN)
9895                     {
9896                       printf (" ORIGIN");
9897                       val ^= DF_1_ORIGIN;
9898                     }
9899                   if (val & DF_1_DIRECT)
9900                     {
9901                       printf (" DIRECT");
9902                       val ^= DF_1_DIRECT;
9903                     }
9904                   if (val & DF_1_TRANS)
9905                     {
9906                       printf (" TRANS");
9907                       val ^= DF_1_TRANS;
9908                     }
9909                   if (val & DF_1_INTERPOSE)
9910                     {
9911                       printf (" INTERPOSE");
9912                       val ^= DF_1_INTERPOSE;
9913                     }
9914                   if (val & DF_1_NODEFLIB)
9915                     {
9916                       printf (" NODEFLIB");
9917                       val ^= DF_1_NODEFLIB;
9918                     }
9919                   if (val & DF_1_NODUMP)
9920                     {
9921                       printf (" NODUMP");
9922                       val ^= DF_1_NODUMP;
9923                     }
9924                   if (val & DF_1_CONFALT)
9925                     {
9926                       printf (" CONFALT");
9927                       val ^= DF_1_CONFALT;
9928                     }
9929                   if (val & DF_1_ENDFILTEE)
9930                     {
9931                       printf (" ENDFILTEE");
9932                       val ^= DF_1_ENDFILTEE;
9933                     }
9934                   if (val & DF_1_DISPRELDNE)
9935                     {
9936                       printf (" DISPRELDNE");
9937                       val ^= DF_1_DISPRELDNE;
9938                     }
9939                   if (val & DF_1_DISPRELPND)
9940                     {
9941                       printf (" DISPRELPND");
9942                       val ^= DF_1_DISPRELPND;
9943                     }
9944                   if (val & DF_1_NODIRECT)
9945                     {
9946                       printf (" NODIRECT");
9947                       val ^= DF_1_NODIRECT;
9948                     }
9949                   if (val & DF_1_IGNMULDEF)
9950                     {
9951                       printf (" IGNMULDEF");
9952                       val ^= DF_1_IGNMULDEF;
9953                     }
9954                   if (val & DF_1_NOKSYMS)
9955                     {
9956                       printf (" NOKSYMS");
9957                       val ^= DF_1_NOKSYMS;
9958                     }
9959                   if (val & DF_1_NOHDR)
9960                     {
9961                       printf (" NOHDR");
9962                       val ^= DF_1_NOHDR;
9963                     }
9964                   if (val & DF_1_EDITED)
9965                     {
9966                       printf (" EDITED");
9967                       val ^= DF_1_EDITED;
9968                     }
9969                   if (val & DF_1_NORELOC)
9970                     {
9971                       printf (" NORELOC");
9972                       val ^= DF_1_NORELOC;
9973                     }
9974                   if (val & DF_1_SYMINTPOSE)
9975                     {
9976                       printf (" SYMINTPOSE");
9977                       val ^= DF_1_SYMINTPOSE;
9978                     }
9979                   if (val & DF_1_GLOBAUDIT)
9980                     {
9981                       printf (" GLOBAUDIT");
9982                       val ^= DF_1_GLOBAUDIT;
9983                     }
9984                   if (val & DF_1_SINGLETON)
9985                     {
9986                       printf (" SINGLETON");
9987                       val ^= DF_1_SINGLETON;
9988                     }
9989                   if (val & DF_1_STUB)
9990                     {
9991                       printf (" STUB");
9992                       val ^= DF_1_STUB;
9993                     }
9994                   if (val & DF_1_PIE)
9995                     {
9996                       printf (" PIE");
9997                       val ^= DF_1_PIE;
9998                     }
9999                   if (val != 0)
10000                     printf (" %lx", val);
10001                   puts ("");
10002                 }
10003             }
10004           break;
10005
10006         case DT_PLTREL:
10007           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10008           if (do_dynamic)
10009             puts (get_dynamic_type (filedata, entry->d_un.d_val));
10010           break;
10011
10012         case DT_NULL    :
10013         case DT_NEEDED  :
10014         case DT_PLTGOT  :
10015         case DT_HASH    :
10016         case DT_STRTAB  :
10017         case DT_SYMTAB  :
10018         case DT_RELA    :
10019         case DT_INIT    :
10020         case DT_FINI    :
10021         case DT_SONAME  :
10022         case DT_RPATH   :
10023         case DT_SYMBOLIC:
10024         case DT_REL     :
10025         case DT_DEBUG   :
10026         case DT_TEXTREL :
10027         case DT_JMPREL  :
10028         case DT_RUNPATH :
10029           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10030
10031           if (do_dynamic)
10032             {
10033               char * name;
10034
10035               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10036                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10037               else
10038                 name = NULL;
10039
10040               if (name)
10041                 {
10042                   switch (entry->d_tag)
10043                     {
10044                     case DT_NEEDED:
10045                       printf (_("Shared library: [%s]"), name);
10046
10047                       if (streq (name, program_interpreter))
10048                         printf (_(" program interpreter"));
10049                       break;
10050
10051                     case DT_SONAME:
10052                       printf (_("Library soname: [%s]"), name);
10053                       break;
10054
10055                     case DT_RPATH:
10056                       printf (_("Library rpath: [%s]"), name);
10057                       break;
10058
10059                     case DT_RUNPATH:
10060                       printf (_("Library runpath: [%s]"), name);
10061                       break;
10062
10063                     default:
10064                       print_vma (entry->d_un.d_val, PREFIX_HEX);
10065                       break;
10066                     }
10067                 }
10068               else
10069                 print_vma (entry->d_un.d_val, PREFIX_HEX);
10070
10071               putchar ('\n');
10072             }
10073           break;
10074
10075         case DT_PLTRELSZ:
10076         case DT_RELASZ  :
10077         case DT_STRSZ   :
10078         case DT_RELSZ   :
10079         case DT_RELAENT :
10080         case DT_SYMENT  :
10081         case DT_RELENT  :
10082           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10083           /* Fall through.  */
10084         case DT_PLTPADSZ:
10085         case DT_MOVEENT :
10086         case DT_MOVESZ  :
10087         case DT_INIT_ARRAYSZ:
10088         case DT_FINI_ARRAYSZ:
10089         case DT_GNU_CONFLICTSZ:
10090         case DT_GNU_LIBLISTSZ:
10091           if (do_dynamic)
10092             {
10093               print_vma (entry->d_un.d_val, UNSIGNED);
10094               printf (_(" (bytes)\n"));
10095             }
10096           break;
10097
10098         case DT_VERDEFNUM:
10099         case DT_VERNEEDNUM:
10100         case DT_RELACOUNT:
10101         case DT_RELCOUNT:
10102           if (do_dynamic)
10103             {
10104               print_vma (entry->d_un.d_val, UNSIGNED);
10105               putchar ('\n');
10106             }
10107           break;
10108
10109         case DT_SYMINSZ:
10110         case DT_SYMINENT:
10111         case DT_SYMINFO:
10112         case DT_USED:
10113         case DT_INIT_ARRAY:
10114         case DT_FINI_ARRAY:
10115           if (do_dynamic)
10116             {
10117               if (entry->d_tag == DT_USED
10118                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10119                 {
10120                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10121
10122                   if (*name)
10123                     {
10124                       printf (_("Not needed object: [%s]\n"), name);
10125                       break;
10126                     }
10127                 }
10128
10129               print_vma (entry->d_un.d_val, PREFIX_HEX);
10130               putchar ('\n');
10131             }
10132           break;
10133
10134         case DT_BIND_NOW:
10135           /* The value of this entry is ignored.  */
10136           if (do_dynamic)
10137             putchar ('\n');
10138           break;
10139
10140         case DT_GNU_PRELINKED:
10141           if (do_dynamic)
10142             {
10143               struct tm * tmp;
10144               time_t atime = entry->d_un.d_val;
10145
10146               tmp = gmtime (&atime);
10147               /* PR 17533 file: 041-1244816-0.004.  */
10148               if (tmp == NULL)
10149                 printf (_("<corrupt time val: %lx"),
10150                         (unsigned long) atime);
10151               else
10152                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10153                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10154                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10155
10156             }
10157           break;
10158
10159         case DT_GNU_HASH:
10160           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10161           if (do_dynamic)
10162             {
10163               print_vma (entry->d_un.d_val, PREFIX_HEX);
10164               putchar ('\n');
10165             }
10166           break;
10167
10168         default:
10169           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10170             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10171               entry->d_un.d_val;
10172
10173           if (do_dynamic)
10174             {
10175               switch (filedata->file_header.e_machine)
10176                 {
10177                 case EM_MIPS:
10178                 case EM_MIPS_RS3_LE:
10179                   dynamic_section_mips_val (entry);
10180                   break;
10181                 case EM_PARISC:
10182                   dynamic_section_parisc_val (entry);
10183                   break;
10184                 case EM_IA_64:
10185                   dynamic_section_ia64_val (entry);
10186                   break;
10187                 default:
10188                   print_vma (entry->d_un.d_val, PREFIX_HEX);
10189                   putchar ('\n');
10190                 }
10191             }
10192           break;
10193         }
10194     }
10195
10196   return TRUE;
10197 }
10198
10199 static char *
10200 get_ver_flags (unsigned int flags)
10201 {
10202   static char buff[32];
10203
10204   buff[0] = 0;
10205
10206   if (flags == 0)
10207     return _("none");
10208
10209   if (flags & VER_FLG_BASE)
10210     strcat (buff, "BASE");
10211
10212   if (flags & VER_FLG_WEAK)
10213     {
10214       if (flags & VER_FLG_BASE)
10215         strcat (buff, " | ");
10216
10217       strcat (buff, "WEAK");
10218     }
10219
10220   if (flags & VER_FLG_INFO)
10221     {
10222       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10223         strcat (buff, " | ");
10224
10225       strcat (buff, "INFO");
10226     }
10227
10228   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10229     {
10230       if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10231         strcat (buff, " | ");
10232
10233       strcat (buff, _("<unknown>"));
10234     }
10235
10236   return buff;
10237 }
10238
10239 /* Display the contents of the version sections.  */
10240
10241 static bfd_boolean
10242 process_version_sections (Filedata * filedata)
10243 {
10244   Elf_Internal_Shdr * section;
10245   unsigned i;
10246   bfd_boolean found = FALSE;
10247
10248   if (! do_version)
10249     return TRUE;
10250
10251   for (i = 0, section = filedata->section_headers;
10252        i < filedata->file_header.e_shnum;
10253        i++, section++)
10254     {
10255       switch (section->sh_type)
10256         {
10257         case SHT_GNU_verdef:
10258           {
10259             Elf_External_Verdef * edefs;
10260             unsigned long idx;
10261             unsigned long cnt;
10262             char * endbuf;
10263
10264             found = TRUE;
10265
10266             printf (ngettext ("\nVersion definition section '%s' "
10267                               "contains %u entry:\n",
10268                               "\nVersion definition section '%s' "
10269                               "contains %u entries:\n",
10270                               section->sh_info),
10271                     printable_section_name (filedata, section),
10272                     section->sh_info);
10273
10274             printf (_("  Addr: 0x"));
10275             printf_vma (section->sh_addr);
10276             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10277                     (unsigned long) section->sh_offset, section->sh_link,
10278                     printable_section_name_from_index (filedata, section->sh_link));
10279
10280             edefs = (Elf_External_Verdef *)
10281                 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
10282                           _("version definition section"));
10283             if (!edefs)
10284               break;
10285             endbuf = (char *) edefs + section->sh_size;
10286
10287             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10288               {
10289                 char * vstart;
10290                 Elf_External_Verdef * edef;
10291                 Elf_Internal_Verdef ent;
10292                 Elf_External_Verdaux * eaux;
10293                 Elf_Internal_Verdaux aux;
10294                 unsigned long isum;
10295                 int j;
10296
10297                 vstart = ((char *) edefs) + idx;
10298                 if (vstart + sizeof (*edef) > endbuf)
10299                   break;
10300
10301                 edef = (Elf_External_Verdef *) vstart;
10302
10303                 ent.vd_version = BYTE_GET (edef->vd_version);
10304                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
10305                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
10306                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
10307                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
10308                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
10309                 ent.vd_next    = BYTE_GET (edef->vd_next);
10310
10311                 printf (_("  %#06lx: Rev: %d  Flags: %s"),
10312                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10313
10314                 printf (_("  Index: %d  Cnt: %d  "),
10315                         ent.vd_ndx, ent.vd_cnt);
10316
10317                 /* Check for overflow.  */
10318                 if (ent.vd_aux > (size_t) (endbuf - vstart))
10319                   break;
10320
10321                 vstart += ent.vd_aux;
10322
10323                 if (vstart + sizeof (*eaux) > endbuf)
10324                   break;
10325                 eaux = (Elf_External_Verdaux *) vstart;
10326
10327                 aux.vda_name = BYTE_GET (eaux->vda_name);
10328                 aux.vda_next = BYTE_GET (eaux->vda_next);
10329
10330                 if (VALID_DYNAMIC_NAME (aux.vda_name))
10331                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10332                 else
10333                   printf (_("Name index: %ld\n"), aux.vda_name);
10334
10335                 isum = idx + ent.vd_aux;
10336
10337                 for (j = 1; j < ent.vd_cnt; j++)
10338                   {
10339                     if (aux.vda_next < sizeof (*eaux)
10340                         && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10341                       {
10342                         warn (_("Invalid vda_next field of %lx\n"),
10343                               aux.vda_next);
10344                         j = ent.vd_cnt;
10345                         break;
10346                       }
10347                     /* Check for overflow.  */
10348                     if (aux.vda_next > (size_t) (endbuf - vstart))
10349                       break;
10350
10351                     isum   += aux.vda_next;
10352                     vstart += aux.vda_next;
10353
10354                     if (vstart + sizeof (*eaux) > endbuf)
10355                       break;
10356                     eaux = (Elf_External_Verdaux *) vstart;
10357
10358                     aux.vda_name = BYTE_GET (eaux->vda_name);
10359                     aux.vda_next = BYTE_GET (eaux->vda_next);
10360
10361                     if (VALID_DYNAMIC_NAME (aux.vda_name))
10362                       printf (_("  %#06lx: Parent %d: %s\n"),
10363                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10364                     else
10365                       printf (_("  %#06lx: Parent %d, name index: %ld\n"),
10366                               isum, j, aux.vda_name);
10367                   }
10368
10369                 if (j < ent.vd_cnt)
10370                   printf (_("  Version def aux past end of section\n"));
10371
10372                 /* PR 17531:
10373                    file: id:000001,src:000172+005151,op:splice,rep:2.  */
10374                 if (ent.vd_next < sizeof (*edef)
10375                     && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10376                   {
10377                     warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10378                     cnt = section->sh_info;
10379                     break;
10380                   }
10381                 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10382                   break;
10383
10384                 idx += ent.vd_next;
10385               }
10386
10387             if (cnt < section->sh_info)
10388               printf (_("  Version definition past end of section\n"));
10389
10390             free (edefs);
10391           }
10392           break;
10393
10394         case SHT_GNU_verneed:
10395           {
10396             Elf_External_Verneed * eneed;
10397             unsigned long idx;
10398             unsigned long cnt;
10399             char * endbuf;
10400
10401             found = TRUE;
10402
10403             printf (ngettext ("\nVersion needs section '%s' "
10404                               "contains %u entry:\n",
10405                               "\nVersion needs section '%s' "
10406                               "contains %u entries:\n",
10407                               section->sh_info),
10408                     printable_section_name (filedata, section), section->sh_info);
10409
10410             printf (_(" Addr: 0x"));
10411             printf_vma (section->sh_addr);
10412             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10413                     (unsigned long) section->sh_offset, section->sh_link,
10414                     printable_section_name_from_index (filedata, section->sh_link));
10415
10416             eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
10417                                                        section->sh_offset, 1,
10418                                                        section->sh_size,
10419                                                        _("Version Needs section"));
10420             if (!eneed)
10421               break;
10422             endbuf = (char *) eneed + section->sh_size;
10423
10424             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10425               {
10426                 Elf_External_Verneed * entry;
10427                 Elf_Internal_Verneed ent;
10428                 unsigned long isum;
10429                 int j;
10430                 char * vstart;
10431
10432                 vstart = ((char *) eneed) + idx;
10433                 if (vstart + sizeof (*entry) > endbuf)
10434                   break;
10435
10436                 entry = (Elf_External_Verneed *) vstart;
10437
10438                 ent.vn_version = BYTE_GET (entry->vn_version);
10439                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
10440                 ent.vn_file    = BYTE_GET (entry->vn_file);
10441                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
10442                 ent.vn_next    = BYTE_GET (entry->vn_next);
10443
10444                 printf (_("  %#06lx: Version: %d"), idx, ent.vn_version);
10445
10446                 if (VALID_DYNAMIC_NAME (ent.vn_file))
10447                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10448                 else
10449                   printf (_("  File: %lx"), ent.vn_file);
10450
10451                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
10452
10453                 /* Check for overflow.  */
10454                 if (ent.vn_aux > (size_t) (endbuf - vstart))
10455                   break;
10456                 vstart += ent.vn_aux;
10457
10458                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10459                   {
10460                     Elf_External_Vernaux * eaux;
10461                     Elf_Internal_Vernaux aux;
10462
10463                     if (vstart + sizeof (*eaux) > endbuf)
10464                       break;
10465                     eaux = (Elf_External_Vernaux *) vstart;
10466
10467                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
10468                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
10469                     aux.vna_other = BYTE_GET (eaux->vna_other);
10470                     aux.vna_name  = BYTE_GET (eaux->vna_name);
10471                     aux.vna_next  = BYTE_GET (eaux->vna_next);
10472
10473                     if (VALID_DYNAMIC_NAME (aux.vna_name))
10474                       printf (_("  %#06lx:   Name: %s"),
10475                               isum, GET_DYNAMIC_NAME (aux.vna_name));
10476                     else
10477                       printf (_("  %#06lx:   Name index: %lx"),
10478                               isum, aux.vna_name);
10479
10480                     printf (_("  Flags: %s  Version: %d\n"),
10481                             get_ver_flags (aux.vna_flags), aux.vna_other);
10482
10483                     if (aux.vna_next < sizeof (*eaux)
10484                         && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10485                       {
10486                         warn (_("Invalid vna_next field of %lx\n"),
10487                               aux.vna_next);
10488                         j = ent.vn_cnt;
10489                         break;
10490                       }
10491                     /* Check for overflow.  */
10492                     if (aux.vna_next > (size_t) (endbuf - vstart))
10493                       break;
10494                     isum   += aux.vna_next;
10495                     vstart += aux.vna_next;
10496                   }
10497
10498                 if (j < ent.vn_cnt)
10499                   warn (_("Missing Version Needs auxillary information\n"));
10500
10501                 if (ent.vn_next < sizeof (*entry)
10502                     && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10503                   {
10504                     warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10505                     cnt = section->sh_info;
10506                     break;
10507                   }
10508                 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10509                   break;
10510                 idx += ent.vn_next;
10511               }
10512
10513             if (cnt < section->sh_info)
10514               warn (_("Missing Version Needs information\n"));
10515
10516             free (eneed);
10517           }
10518           break;
10519
10520         case SHT_GNU_versym:
10521           {
10522             Elf_Internal_Shdr * link_section;
10523             size_t total;
10524             unsigned int cnt;
10525             unsigned char * edata;
10526             unsigned short * data;
10527             char * strtab;
10528             Elf_Internal_Sym * symbols;
10529             Elf_Internal_Shdr * string_sec;
10530             unsigned long num_syms;
10531             long off;
10532
10533             if (section->sh_link >= filedata->file_header.e_shnum)
10534               break;
10535
10536             link_section = filedata->section_headers + section->sh_link;
10537             total = section->sh_size / sizeof (Elf_External_Versym);
10538
10539             if (link_section->sh_link >= filedata->file_header.e_shnum)
10540               break;
10541
10542             found = TRUE;
10543
10544             symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
10545             if (symbols == NULL)
10546               break;
10547
10548             string_sec = filedata->section_headers + link_section->sh_link;
10549
10550             strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
10551                                         string_sec->sh_size,
10552                                         _("version string table"));
10553             if (!strtab)
10554               {
10555                 free (symbols);
10556                 break;
10557               }
10558
10559             printf (ngettext ("\nVersion symbols section '%s' "
10560                               "contains %lu entry:\n",
10561                               "\nVersion symbols section '%s' "
10562                               "contains %lu entries:\n",
10563                               total),
10564                     printable_section_name (filedata, section), (unsigned long) total);
10565
10566             printf (_(" Addr: "));
10567             printf_vma (section->sh_addr);
10568             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10569                     (unsigned long) section->sh_offset, section->sh_link,
10570                     printable_section_name (filedata, link_section));
10571
10572             off = offset_from_vma (filedata,
10573                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10574                                    total * sizeof (short));
10575             edata = (unsigned char *) get_data (NULL, filedata, off, total,
10576                                                 sizeof (short),
10577                                                 _("version symbol data"));
10578             if (!edata)
10579               {
10580                 free (strtab);
10581                 free (symbols);
10582                 break;
10583               }
10584
10585             data = (short unsigned int *) cmalloc (total, sizeof (short));
10586
10587             for (cnt = total; cnt --;)
10588               data[cnt] = byte_get (edata + cnt * sizeof (short),
10589                                     sizeof (short));
10590
10591             free (edata);
10592
10593             for (cnt = 0; cnt < total; cnt += 4)
10594               {
10595                 int j, nn;
10596                 char *name;
10597                 char *invalid = _("*invalid*");
10598
10599                 printf ("  %03x:", cnt);
10600
10601                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10602                   switch (data[cnt + j])
10603                     {
10604                     case 0:
10605                       fputs (_("   0 (*local*)    "), stdout);
10606                       break;
10607
10608                     case 1:
10609                       fputs (_("   1 (*global*)   "), stdout);
10610                       break;
10611
10612                     default:
10613                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10614                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10615
10616                       /* If this index value is greater than the size of the symbols
10617                          array, break to avoid an out-of-bounds read.  */
10618                       if ((unsigned long)(cnt + j) >= num_syms)
10619                         {
10620                           warn (_("invalid index into symbol array\n"));
10621                           break;
10622                         }
10623
10624                       name = NULL;
10625                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10626                         {
10627                           Elf_Internal_Verneed ivn;
10628                           unsigned long offset;
10629
10630                           offset = offset_from_vma
10631                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10632                              sizeof (Elf_External_Verneed));
10633
10634                           do
10635                             {
10636                               Elf_Internal_Vernaux ivna;
10637                               Elf_External_Verneed evn;
10638                               Elf_External_Vernaux evna;
10639                               unsigned long a_off;
10640
10641                               if (get_data (&evn, filedata, offset, sizeof (evn), 1,
10642                                             _("version need")) == NULL)
10643                                 break;
10644
10645                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10646                               ivn.vn_next = BYTE_GET (evn.vn_next);
10647
10648                               a_off = offset + ivn.vn_aux;
10649
10650                               do
10651                                 {
10652                                   if (get_data (&evna, filedata, a_off, sizeof (evna),
10653                                                 1, _("version need aux (2)")) == NULL)
10654                                     {
10655                                       ivna.vna_next  = 0;
10656                                       ivna.vna_other = 0;
10657                                     }
10658                                   else
10659                                     {
10660                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
10661                                       ivna.vna_other = BYTE_GET (evna.vna_other);
10662                                     }
10663
10664                                   a_off += ivna.vna_next;
10665                                 }
10666                               while (ivna.vna_other != data[cnt + j]
10667                                      && ivna.vna_next != 0);
10668
10669                               if (ivna.vna_other == data[cnt + j])
10670                                 {
10671                                   ivna.vna_name = BYTE_GET (evna.vna_name);
10672
10673                                   if (ivna.vna_name >= string_sec->sh_size)
10674                                     name = invalid;
10675                                   else
10676                                     name = strtab + ivna.vna_name;
10677                                   break;
10678                                 }
10679
10680                               offset += ivn.vn_next;
10681                             }
10682                           while (ivn.vn_next);
10683                         }
10684
10685                       if (data[cnt + j] != 0x8001
10686                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10687                         {
10688                           Elf_Internal_Verdef ivd;
10689                           Elf_External_Verdef evd;
10690                           unsigned long offset;
10691
10692                           offset = offset_from_vma
10693                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10694                              sizeof evd);
10695
10696                           do
10697                             {
10698                               if (get_data (&evd, filedata, offset, sizeof (evd), 1,
10699                                             _("version def")) == NULL)
10700                                 {
10701                                   ivd.vd_next = 0;
10702                                   /* PR 17531: file: 046-1082287-0.004.  */
10703                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
10704                                   break;
10705                                 }
10706                               else
10707                                 {
10708                                   ivd.vd_next = BYTE_GET (evd.vd_next);
10709                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
10710                                 }
10711
10712                               offset += ivd.vd_next;
10713                             }
10714                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10715                                  && ivd.vd_next != 0);
10716
10717                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10718                             {
10719                               Elf_External_Verdaux evda;
10720                               Elf_Internal_Verdaux ivda;
10721
10722                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
10723
10724                               if (get_data (&evda, filedata,
10725                                             offset - ivd.vd_next + ivd.vd_aux,
10726                                             sizeof (evda), 1,
10727                                             _("version def aux")) == NULL)
10728                                 break;
10729
10730                               ivda.vda_name = BYTE_GET (evda.vda_name);
10731
10732                               if (ivda.vda_name >= string_sec->sh_size)
10733                                 name = invalid;
10734                               else if (name != NULL && name != invalid)
10735                                 name = _("*both*");
10736                               else
10737                                 name = strtab + ivda.vda_name;
10738                             }
10739                         }
10740                       if (name != NULL)
10741                         nn += printf ("(%s%-*s",
10742                                       name,
10743                                       12 - (int) strlen (name),
10744                                       ")");
10745
10746                       if (nn < 18)
10747                         printf ("%*c", 18 - nn, ' ');
10748                     }
10749
10750                 putchar ('\n');
10751               }
10752
10753             free (data);
10754             free (strtab);
10755             free (symbols);
10756           }
10757           break;
10758
10759         default:
10760           break;
10761         }
10762     }
10763
10764   if (! found)
10765     printf (_("\nNo version information found in this file.\n"));
10766
10767   return TRUE;
10768 }
10769
10770 static const char *
10771 get_symbol_binding (Filedata * filedata, unsigned int binding)
10772 {
10773   static char buff[32];
10774
10775   switch (binding)
10776     {
10777     case STB_LOCAL:     return "LOCAL";
10778     case STB_GLOBAL:    return "GLOBAL";
10779     case STB_WEAK:      return "WEAK";
10780     default:
10781       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10782         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10783                   binding);
10784       else if (binding >= STB_LOOS && binding <= STB_HIOS)
10785         {
10786           if (binding == STB_GNU_UNIQUE
10787               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10788                   /* GNU is still using the default value 0.  */
10789                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10790             return "UNIQUE";
10791           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10792         }
10793       else
10794         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10795       return buff;
10796     }
10797 }
10798
10799 static const char *
10800 get_symbol_type (Filedata * filedata, unsigned int type)
10801 {
10802   static char buff[32];
10803
10804   switch (type)
10805     {
10806     case STT_NOTYPE:    return "NOTYPE";
10807     case STT_OBJECT:    return "OBJECT";
10808     case STT_FUNC:      return "FUNC";
10809     case STT_SECTION:   return "SECTION";
10810     case STT_FILE:      return "FILE";
10811     case STT_COMMON:    return "COMMON";
10812     case STT_TLS:       return "TLS";
10813     case STT_RELC:      return "RELC";
10814     case STT_SRELC:     return "SRELC";
10815     default:
10816       if (type >= STT_LOPROC && type <= STT_HIPROC)
10817         {
10818           if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10819             return "THUMB_FUNC";
10820
10821           if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10822             return "REGISTER";
10823
10824           if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10825             return "PARISC_MILLI";
10826
10827           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10828         }
10829       else if (type >= STT_LOOS && type <= STT_HIOS)
10830         {
10831           if (filedata->file_header.e_machine == EM_PARISC)
10832             {
10833               if (type == STT_HP_OPAQUE)
10834                 return "HP_OPAQUE";
10835               if (type == STT_HP_STUB)
10836                 return "HP_STUB";
10837             }
10838
10839           if (type == STT_GNU_IFUNC
10840               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10841                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10842                   /* GNU is still using the default value 0.  */
10843                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10844             return "IFUNC";
10845
10846           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10847         }
10848       else
10849         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10850       return buff;
10851     }
10852 }
10853
10854 static const char *
10855 get_symbol_visibility (unsigned int visibility)
10856 {
10857   switch (visibility)
10858     {
10859     case STV_DEFAULT:   return "DEFAULT";
10860     case STV_INTERNAL:  return "INTERNAL";
10861     case STV_HIDDEN:    return "HIDDEN";
10862     case STV_PROTECTED: return "PROTECTED";
10863     default:
10864       error (_("Unrecognized visibility value: %u"), visibility);
10865       return _("<unknown>");
10866     }
10867 }
10868
10869 static const char *
10870 get_solaris_symbol_visibility (unsigned int visibility)
10871 {
10872   switch (visibility)
10873     {
10874     case 4: return "EXPORTED";
10875     case 5: return "SINGLETON";
10876     case 6: return "ELIMINATE";
10877     default: return get_symbol_visibility (visibility);
10878     }
10879 }
10880
10881 static const char *
10882 get_mips_symbol_other (unsigned int other)
10883 {
10884   switch (other)
10885     {
10886     case STO_OPTIONAL:      return "OPTIONAL";
10887     case STO_MIPS_PLT:      return "MIPS PLT";
10888     case STO_MIPS_PIC:      return "MIPS PIC";
10889     case STO_MICROMIPS:     return "MICROMIPS";
10890     case STO_MICROMIPS | STO_MIPS_PIC:      return "MICROMIPS, MIPS PIC";
10891     case STO_MIPS16:        return "MIPS16";
10892     default:                return NULL;
10893     }
10894 }
10895
10896 static const char *
10897 get_ia64_symbol_other (Filedata * filedata, unsigned int other)
10898 {
10899   if (is_ia64_vms (filedata))
10900     {
10901       static char res[32];
10902
10903       res[0] = 0;
10904
10905       /* Function types is for images and .STB files only.  */
10906       switch (filedata->file_header.e_type)
10907         {
10908         case ET_DYN:
10909         case ET_EXEC:
10910           switch (VMS_ST_FUNC_TYPE (other))
10911             {
10912             case VMS_SFT_CODE_ADDR:
10913               strcat (res, " CA");
10914               break;
10915             case VMS_SFT_SYMV_IDX:
10916               strcat (res, " VEC");
10917               break;
10918             case VMS_SFT_FD:
10919               strcat (res, " FD");
10920               break;
10921             case VMS_SFT_RESERVE:
10922               strcat (res, " RSV");
10923               break;
10924             default:
10925               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10926                     VMS_ST_FUNC_TYPE (other));
10927               strcat (res, " <unknown>");
10928               break;
10929             }
10930           break;
10931         default:
10932           break;
10933         }
10934       switch (VMS_ST_LINKAGE (other))
10935         {
10936         case VMS_STL_IGNORE:
10937           strcat (res, " IGN");
10938           break;
10939         case VMS_STL_RESERVE:
10940           strcat (res, " RSV");
10941           break;
10942         case VMS_STL_STD:
10943           strcat (res, " STD");
10944           break;
10945         case VMS_STL_LNK:
10946           strcat (res, " LNK");
10947           break;
10948         default:
10949           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10950                 VMS_ST_LINKAGE (other));
10951           strcat (res, " <unknown>");
10952           break;
10953         }
10954
10955       if (res[0] != 0)
10956         return res + 1;
10957       else
10958         return res;
10959     }
10960   return NULL;
10961 }
10962
10963 static const char *
10964 get_ppc64_symbol_other (unsigned int other)
10965 {
10966   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10967     {
10968       static char buf[32];
10969       snprintf (buf, sizeof buf, _("<localentry>: %d"),
10970                 PPC64_LOCAL_ENTRY_OFFSET (other));
10971       return buf;
10972     }
10973   return NULL;
10974 }
10975
10976 static const char *
10977 get_symbol_other (Filedata * filedata, unsigned int other)
10978 {
10979   const char * result = NULL;
10980   static char buff [32];
10981
10982   if (other == 0)
10983     return "";
10984
10985   switch (filedata->file_header.e_machine)
10986     {
10987     case EM_MIPS:
10988       result = get_mips_symbol_other (other);
10989       break;
10990     case EM_IA_64:
10991       result = get_ia64_symbol_other (filedata, other);
10992       break;
10993     case EM_PPC64:
10994       result = get_ppc64_symbol_other (other);
10995       break;
10996     default:
10997       result = NULL;
10998       break;
10999     }
11000
11001   if (result)
11002     return result;
11003
11004   snprintf (buff, sizeof buff, _("<other>: %x"), other);
11005   return buff;
11006 }
11007
11008 static const char *
11009 get_symbol_index_type (Filedata * filedata, unsigned int type)
11010 {
11011   static char buff[32];
11012
11013   switch (type)
11014     {
11015     case SHN_UNDEF:     return "UND";
11016     case SHN_ABS:       return "ABS";
11017     case SHN_COMMON:    return "COM";
11018     default:
11019       if (type == SHN_IA_64_ANSI_COMMON
11020           && filedata->file_header.e_machine == EM_IA_64
11021           && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11022         return "ANSI_COM";
11023       else if ((filedata->file_header.e_machine == EM_X86_64
11024                 || filedata->file_header.e_machine == EM_L1OM
11025                 || filedata->file_header.e_machine == EM_K1OM)
11026                && type == SHN_X86_64_LCOMMON)
11027         return "LARGE_COM";
11028       else if ((type == SHN_MIPS_SCOMMON
11029                 && filedata->file_header.e_machine == EM_MIPS)
11030                || (type == SHN_TIC6X_SCOMMON
11031                    && filedata->file_header.e_machine == EM_TI_C6000))
11032         return "SCOM";
11033       else if (type == SHN_MIPS_SUNDEFINED
11034                && filedata->file_header.e_machine == EM_MIPS)
11035         return "SUND";
11036       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11037         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11038       else if (type >= SHN_LOOS && type <= SHN_HIOS)
11039         sprintf (buff, "OS [0x%04x]", type & 0xffff);
11040       else if (type >= SHN_LORESERVE)
11041         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11042       else if (type >= filedata->file_header.e_shnum)
11043         sprintf (buff, _("bad section index[%3d]"), type);
11044       else
11045         sprintf (buff, "%3d", type);
11046       break;
11047     }
11048
11049   return buff;
11050 }
11051
11052 static bfd_vma *
11053 get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
11054 {
11055   unsigned char * e_data;
11056   bfd_vma * i_data;
11057
11058   /* If the size_t type is smaller than the bfd_size_type, eg because
11059      you are building a 32-bit tool on a 64-bit host, then make sure
11060      that when (number) is cast to (size_t) no information is lost.  */
11061   if (sizeof (size_t) < sizeof (bfd_size_type)
11062       && (bfd_size_type) ((size_t) number) != number)
11063     {
11064       error (_("Size truncation prevents reading %s elements of size %u\n"),
11065              bfd_vmatoa ("u", number), ent_size);
11066       return NULL;
11067     }
11068
11069   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11070      attempting to allocate memory when the read is bound to fail.  */
11071   if (ent_size * number > filedata->file_size)
11072     {
11073       error (_("Invalid number of dynamic entries: %s\n"),
11074              bfd_vmatoa ("u", number));
11075       return NULL;
11076     }
11077
11078   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11079   if (e_data == NULL)
11080     {
11081       error (_("Out of memory reading %s dynamic entries\n"),
11082              bfd_vmatoa ("u", number));
11083       return NULL;
11084     }
11085
11086   if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
11087     {
11088       error (_("Unable to read in %s bytes of dynamic data\n"),
11089              bfd_vmatoa ("u", number * ent_size));
11090       free (e_data);
11091       return NULL;
11092     }
11093
11094   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11095   if (i_data == NULL)
11096     {
11097       error (_("Out of memory allocating space for %s dynamic entries\n"),
11098              bfd_vmatoa ("u", number));
11099       free (e_data);
11100       return NULL;
11101     }
11102
11103   while (number--)
11104     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11105
11106   free (e_data);
11107
11108   return i_data;
11109 }
11110
11111 static void
11112 print_dynamic_symbol (Filedata * filedata, bfd_vma si, unsigned long hn)
11113 {
11114   Elf_Internal_Sym * psym;
11115   int n;
11116
11117   n = print_vma (si, DEC_5);
11118   if (n < 5)
11119     fputs (&"     "[n], stdout);
11120   printf (" %3lu: ", hn);
11121
11122   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11123     {
11124       printf (_("<No info available for dynamic symbol number %lu>\n"),
11125               (unsigned long) si);
11126       return;
11127     }
11128
11129   psym = dynamic_symbols + si;
11130   print_vma (psym->st_value, LONG_HEX);
11131   putchar (' ');
11132   print_vma (psym->st_size, DEC_5);
11133
11134   printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11135   printf (" %-6s",  get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11136
11137   if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11138     printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11139   else
11140     {
11141       unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11142
11143       printf (" %-7s",  get_symbol_visibility (vis));
11144       /* Check to see if any other bits in the st_other field are set.
11145          Note - displaying this information disrupts the layout of the
11146          table being generated, but for the moment this case is very
11147          rare.  */
11148       if (psym->st_other ^ vis)
11149         printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11150     }
11151
11152   printf (" %3.3s ", get_symbol_index_type (filedata, psym->st_shndx));
11153   if (VALID_DYNAMIC_NAME (psym->st_name))
11154     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11155   else
11156     printf (_(" <corrupt: %14ld>"), psym->st_name);
11157   putchar ('\n');
11158 }
11159
11160 static const char *
11161 get_symbol_version_string (Filedata *                   filedata,
11162                            bfd_boolean                  is_dynsym,
11163                            const char *                 strtab,
11164                            unsigned long int            strtab_size,
11165                            unsigned int                 si,
11166                            Elf_Internal_Sym *           psym,
11167                            enum versioned_symbol_info * sym_info,
11168                            unsigned short *             vna_other)
11169 {
11170   unsigned char data[2];
11171   unsigned short vers_data;
11172   unsigned long offset;
11173
11174   if (!is_dynsym
11175       || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11176     return NULL;
11177
11178   offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11179                             sizeof data + si * sizeof (vers_data));
11180
11181   if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11182                 sizeof (data), 1, _("version data")) == NULL)
11183     return NULL;
11184
11185   vers_data = byte_get (data, 2);
11186
11187   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
11188     return NULL;
11189
11190   /* Usually we'd only see verdef for defined symbols, and verneed for
11191      undefined symbols.  However, symbols defined by the linker in
11192      .dynbss for variables copied from a shared library in order to
11193      avoid text relocations are defined yet have verneed.  We could
11194      use a heuristic to detect the special case, for example, check
11195      for verneed first on symbols defined in SHT_NOBITS sections, but
11196      it is simpler and more reliable to just look for both verdef and
11197      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
11198
11199   if (psym->st_shndx != SHN_UNDEF
11200       && vers_data != 0x8001
11201       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11202     {
11203       Elf_Internal_Verdef ivd;
11204       Elf_Internal_Verdaux ivda;
11205       Elf_External_Verdaux evda;
11206       unsigned long off;
11207
11208       off = offset_from_vma (filedata,
11209                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11210                              sizeof (Elf_External_Verdef));
11211
11212       do
11213         {
11214           Elf_External_Verdef evd;
11215
11216           if (get_data (&evd, filedata, off, sizeof (evd), 1,
11217                         _("version def")) == NULL)
11218             {
11219               ivd.vd_ndx = 0;
11220               ivd.vd_aux = 0;
11221               ivd.vd_next = 0;
11222             }
11223           else
11224             {
11225               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11226               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11227               ivd.vd_next = BYTE_GET (evd.vd_next);
11228             }
11229
11230           off += ivd.vd_next;
11231         }
11232       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11233
11234       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11235         {
11236           off -= ivd.vd_next;
11237           off += ivd.vd_aux;
11238
11239           if (get_data (&evda, filedata, off, sizeof (evda), 1,
11240                         _("version def aux")) != NULL)
11241             {
11242               ivda.vda_name = BYTE_GET (evda.vda_name);
11243
11244               if (psym->st_name != ivda.vda_name)
11245                 {
11246                   *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11247                                ? symbol_hidden : symbol_public);
11248                   return (ivda.vda_name < strtab_size
11249                           ? strtab + ivda.vda_name : _("<corrupt>"));
11250                 }
11251             }
11252         }
11253     }
11254
11255   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11256     {
11257       Elf_External_Verneed evn;
11258       Elf_Internal_Verneed ivn;
11259       Elf_Internal_Vernaux ivna;
11260
11261       offset = offset_from_vma (filedata,
11262                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11263                                 sizeof evn);
11264       do
11265         {
11266           unsigned long vna_off;
11267
11268           if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11269                         _("version need")) == NULL)
11270             {
11271               ivna.vna_next = 0;
11272               ivna.vna_other = 0;
11273               ivna.vna_name = 0;
11274               break;
11275             }
11276
11277           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
11278           ivn.vn_next = BYTE_GET (evn.vn_next);
11279
11280           vna_off = offset + ivn.vn_aux;
11281
11282           do
11283             {
11284               Elf_External_Vernaux evna;
11285
11286               if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11287                             _("version need aux (3)")) == NULL)
11288                 {
11289                   ivna.vna_next = 0;
11290                   ivna.vna_other = 0;
11291                   ivna.vna_name = 0;
11292                 }
11293               else
11294                 {
11295                   ivna.vna_other = BYTE_GET (evna.vna_other);
11296                   ivna.vna_next  = BYTE_GET (evna.vna_next);
11297                   ivna.vna_name  = BYTE_GET (evna.vna_name);
11298                 }
11299
11300               vna_off += ivna.vna_next;
11301             }
11302           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11303
11304           if (ivna.vna_other == vers_data)
11305             break;
11306
11307           offset += ivn.vn_next;
11308         }
11309       while (ivn.vn_next != 0);
11310
11311       if (ivna.vna_other == vers_data)
11312         {
11313           *sym_info = symbol_undefined;
11314           *vna_other = ivna.vna_other;
11315           return (ivna.vna_name < strtab_size
11316                   ? strtab + ivna.vna_name : _("<corrupt>"));
11317         }
11318     }
11319   return NULL;
11320 }
11321
11322 /* Dump the symbol table.  */
11323 static bfd_boolean
11324 process_symbol_table (Filedata * filedata)
11325 {
11326   Elf_Internal_Shdr * section;
11327   bfd_size_type nbuckets = 0;
11328   bfd_size_type nchains = 0;
11329   bfd_vma * buckets = NULL;
11330   bfd_vma * chains = NULL;
11331   bfd_vma ngnubuckets = 0;
11332   bfd_vma * gnubuckets = NULL;
11333   bfd_vma * gnuchains = NULL;
11334   bfd_vma gnusymidx = 0;
11335   bfd_size_type ngnuchains = 0;
11336
11337   if (!do_syms && !do_dyn_syms && !do_histogram)
11338     return TRUE;
11339
11340   if (dynamic_info[DT_HASH]
11341       && (do_histogram
11342           || (do_using_dynamic
11343               && !do_dyn_syms
11344               && dynamic_strings != NULL)))
11345     {
11346       unsigned char nb[8];
11347       unsigned char nc[8];
11348       unsigned int hash_ent_size = 4;
11349
11350       if ((filedata->file_header.e_machine == EM_ALPHA
11351            || filedata->file_header.e_machine == EM_S390
11352            || filedata->file_header.e_machine == EM_S390_OLD)
11353           && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11354         hash_ent_size = 8;
11355
11356       if (fseek (filedata->handle,
11357                  (archive_file_offset
11358                   + offset_from_vma (filedata, dynamic_info[DT_HASH],
11359                                      sizeof nb + sizeof nc)),
11360                  SEEK_SET))
11361         {
11362           error (_("Unable to seek to start of dynamic information\n"));
11363           goto no_hash;
11364         }
11365
11366       if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11367         {
11368           error (_("Failed to read in number of buckets\n"));
11369           goto no_hash;
11370         }
11371
11372       if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11373         {
11374           error (_("Failed to read in number of chains\n"));
11375           goto no_hash;
11376         }
11377
11378       nbuckets = byte_get (nb, hash_ent_size);
11379       nchains  = byte_get (nc, hash_ent_size);
11380
11381       buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11382       chains  = get_dynamic_data (filedata, nchains, hash_ent_size);
11383
11384     no_hash:
11385       if (buckets == NULL || chains == NULL)
11386         {
11387           if (do_using_dynamic)
11388             return FALSE;
11389           free (buckets);
11390           free (chains);
11391           buckets = NULL;
11392           chains = NULL;
11393           nbuckets = 0;
11394           nchains = 0;
11395         }
11396     }
11397
11398   if (dynamic_info_DT_GNU_HASH
11399       && (do_histogram
11400           || (do_using_dynamic
11401               && !do_dyn_syms
11402               && dynamic_strings != NULL)))
11403     {
11404       unsigned char nb[16];
11405       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11406       bfd_vma buckets_vma;
11407
11408       if (fseek (filedata->handle,
11409                  (archive_file_offset
11410                   + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11411                                      sizeof nb)),
11412                  SEEK_SET))
11413         {
11414           error (_("Unable to seek to start of dynamic information\n"));
11415           goto no_gnu_hash;
11416         }
11417
11418       if (fread (nb, 16, 1, filedata->handle) != 1)
11419         {
11420           error (_("Failed to read in number of buckets\n"));
11421           goto no_gnu_hash;
11422         }
11423
11424       ngnubuckets = byte_get (nb, 4);
11425       gnusymidx = byte_get (nb + 4, 4);
11426       bitmaskwords = byte_get (nb + 8, 4);
11427       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11428       if (is_32bit_elf)
11429         buckets_vma += bitmaskwords * 4;
11430       else
11431         buckets_vma += bitmaskwords * 8;
11432
11433       if (fseek (filedata->handle,
11434                  (archive_file_offset
11435                   + offset_from_vma (filedata, buckets_vma, 4)),
11436                  SEEK_SET))
11437         {
11438           error (_("Unable to seek to start of dynamic information\n"));
11439           goto no_gnu_hash;
11440         }
11441
11442       gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11443
11444       if (gnubuckets == NULL)
11445         goto no_gnu_hash;
11446
11447       for (i = 0; i < ngnubuckets; i++)
11448         if (gnubuckets[i] != 0)
11449           {
11450             if (gnubuckets[i] < gnusymidx)
11451               return FALSE;
11452
11453             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11454               maxchain = gnubuckets[i];
11455           }
11456
11457       if (maxchain == 0xffffffff)
11458         goto no_gnu_hash;
11459
11460       maxchain -= gnusymidx;
11461
11462       if (fseek (filedata->handle,
11463                  (archive_file_offset
11464                   + offset_from_vma (filedata, buckets_vma
11465                                            + 4 * (ngnubuckets + maxchain), 4)),
11466                  SEEK_SET))
11467         {
11468           error (_("Unable to seek to start of dynamic information\n"));
11469           goto no_gnu_hash;
11470         }
11471
11472       do
11473         {
11474           if (fread (nb, 4, 1, filedata->handle) != 1)
11475             {
11476               error (_("Failed to determine last chain length\n"));
11477               goto no_gnu_hash;
11478             }
11479
11480           if (maxchain + 1 == 0)
11481             goto no_gnu_hash;
11482
11483           ++maxchain;
11484         }
11485       while ((byte_get (nb, 4) & 1) == 0);
11486
11487       if (fseek (filedata->handle,
11488                  (archive_file_offset
11489                   + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11490                  SEEK_SET))
11491         {
11492           error (_("Unable to seek to start of dynamic information\n"));
11493           goto no_gnu_hash;
11494         }
11495
11496       gnuchains = get_dynamic_data (filedata, maxchain, 4);
11497       ngnuchains = maxchain;
11498
11499     no_gnu_hash:
11500       if (gnuchains == NULL)
11501         {
11502           free (gnubuckets);
11503           gnubuckets = NULL;
11504           ngnubuckets = 0;
11505           if (do_using_dynamic)
11506             return FALSE;
11507         }
11508     }
11509
11510   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11511       && do_syms
11512       && do_using_dynamic
11513       && dynamic_strings != NULL
11514       && dynamic_symbols != NULL)
11515     {
11516       unsigned long hn;
11517
11518       if (dynamic_info[DT_HASH])
11519         {
11520           bfd_vma si;
11521           char *visited;
11522
11523           printf (_("\nSymbol table for image:\n"));
11524           if (is_32bit_elf)
11525             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11526           else
11527             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11528
11529           visited = xcmalloc (nchains, 1);
11530           memset (visited, 0, nchains);
11531           for (hn = 0; hn < nbuckets; hn++)
11532             {
11533               for (si = buckets[hn]; si > 0; si = chains[si])
11534                 {
11535                   print_dynamic_symbol (filedata, si, hn);
11536                   if (si >= nchains || visited[si])
11537                     {
11538                       error (_("histogram chain is corrupt\n"));
11539                       break;
11540                     }
11541                   visited[si] = 1;
11542                 }
11543             }
11544           free (visited);
11545         }
11546
11547       if (dynamic_info_DT_GNU_HASH)
11548         {
11549           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11550           if (is_32bit_elf)
11551             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11552           else
11553             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11554
11555           for (hn = 0; hn < ngnubuckets; ++hn)
11556             if (gnubuckets[hn] != 0)
11557               {
11558                 bfd_vma si = gnubuckets[hn];
11559                 bfd_vma off = si - gnusymidx;
11560
11561                 do
11562                   {
11563                     print_dynamic_symbol (filedata, si, hn);
11564                     si++;
11565                   }
11566                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11567               }
11568         }
11569     }
11570   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11571            && filedata->section_headers != NULL)
11572     {
11573       unsigned int i;
11574
11575       for (i = 0, section = filedata->section_headers;
11576            i < filedata->file_header.e_shnum;
11577            i++, section++)
11578         {
11579           unsigned int si;
11580           char * strtab = NULL;
11581           unsigned long int strtab_size = 0;
11582           Elf_Internal_Sym * symtab;
11583           Elf_Internal_Sym * psym;
11584           unsigned long num_syms;
11585
11586           if ((section->sh_type != SHT_SYMTAB
11587                && section->sh_type != SHT_DYNSYM)
11588               || (!do_syms
11589                   && section->sh_type == SHT_SYMTAB))
11590             continue;
11591
11592           if (section->sh_entsize == 0)
11593             {
11594               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11595                       printable_section_name (filedata, section));
11596               continue;
11597             }
11598
11599           num_syms = section->sh_size / section->sh_entsize;
11600           printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11601                             "\nSymbol table '%s' contains %lu entries:\n",
11602                             num_syms),
11603                   printable_section_name (filedata, section),
11604                   num_syms);
11605
11606           if (is_32bit_elf)
11607             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
11608           else
11609             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
11610
11611           symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
11612           if (symtab == NULL)
11613             continue;
11614
11615           if (section->sh_link == filedata->file_header.e_shstrndx)
11616             {
11617               strtab = filedata->string_table;
11618               strtab_size = filedata->string_table_length;
11619             }
11620           else if (section->sh_link < filedata->file_header.e_shnum)
11621             {
11622               Elf_Internal_Shdr * string_sec;
11623
11624               string_sec = filedata->section_headers + section->sh_link;
11625
11626               strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
11627                                           1, string_sec->sh_size,
11628                                           _("string table"));
11629               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11630             }
11631
11632           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11633             {
11634               const char *version_string;
11635               enum versioned_symbol_info sym_info;
11636               unsigned short vna_other;
11637
11638               printf ("%6d: ", si);
11639               print_vma (psym->st_value, LONG_HEX);
11640               putchar (' ');
11641               print_vma (psym->st_size, DEC_5);
11642               printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11643               printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11644               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11645                 printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11646               else
11647                 {
11648                   unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11649
11650                   printf (" %-7s", get_symbol_visibility (vis));
11651                   /* Check to see if any other bits in the st_other field are set.
11652                      Note - displaying this information disrupts the layout of the
11653                      table being generated, but for the moment this case is very rare.  */
11654                   if (psym->st_other ^ vis)
11655                     printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11656                 }
11657               printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
11658               print_symbol (25, psym->st_name < strtab_size
11659                             ? strtab + psym->st_name : _("<corrupt>"));
11660
11661               version_string
11662                 = get_symbol_version_string (filedata,
11663                                              section->sh_type == SHT_DYNSYM,
11664                                              strtab, strtab_size, si,
11665                                              psym, &sym_info, &vna_other);
11666               if (version_string)
11667                 {
11668                   if (sym_info == symbol_undefined)
11669                     printf ("@%s (%d)", version_string, vna_other);
11670                   else
11671                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11672                             version_string);
11673                 }
11674
11675               putchar ('\n');
11676
11677               if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11678                   && si >= section->sh_info
11679                   /* Irix 5 and 6 MIPS binaries are known to ignore this requirement.  */
11680                   && filedata->file_header.e_machine != EM_MIPS
11681                   /* Solaris binaries have been found to violate this requirement as
11682                      well.  Not sure if this is a bug or an ABI requirement.  */
11683                   && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11684                 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11685                       si, printable_section_name (filedata, section), section->sh_info);
11686             }
11687
11688           free (symtab);
11689           if (strtab != filedata->string_table)
11690             free (strtab);
11691         }
11692     }
11693   else if (do_syms)
11694     printf
11695       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11696
11697   if (do_histogram && buckets != NULL)
11698     {
11699       unsigned long * lengths;
11700       unsigned long * counts;
11701       unsigned long hn;
11702       bfd_vma si;
11703       unsigned long maxlength = 0;
11704       unsigned long nzero_counts = 0;
11705       unsigned long nsyms = 0;
11706       char *visited;
11707
11708       printf (ngettext ("\nHistogram for bucket list length "
11709                         "(total of %lu bucket):\n",
11710                         "\nHistogram for bucket list length "
11711                         "(total of %lu buckets):\n",
11712                         (unsigned long) nbuckets),
11713               (unsigned long) nbuckets);
11714
11715       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11716       if (lengths == NULL)
11717         {
11718           error (_("Out of memory allocating space for histogram buckets\n"));
11719           return FALSE;
11720         }
11721       visited = xcmalloc (nchains, 1);
11722       memset (visited, 0, nchains);
11723
11724       printf (_(" Length  Number     %% of total  Coverage\n"));
11725       for (hn = 0; hn < nbuckets; ++hn)
11726         {
11727           for (si = buckets[hn]; si > 0; si = chains[si])
11728             {
11729               ++nsyms;
11730               if (maxlength < ++lengths[hn])
11731                 ++maxlength;
11732               if (si >= nchains || visited[si])
11733                 {
11734                   error (_("histogram chain is corrupt\n"));
11735                   break;
11736                 }
11737               visited[si] = 1;
11738             }
11739         }
11740       free (visited);
11741
11742       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11743       if (counts == NULL)
11744         {
11745           free (lengths);
11746           error (_("Out of memory allocating space for histogram counts\n"));
11747           return FALSE;
11748         }
11749
11750       for (hn = 0; hn < nbuckets; ++hn)
11751         ++counts[lengths[hn]];
11752
11753       if (nbuckets > 0)
11754         {
11755           unsigned long i;
11756           printf ("      0  %-10lu (%5.1f%%)\n",
11757                   counts[0], (counts[0] * 100.0) / nbuckets);
11758           for (i = 1; i <= maxlength; ++i)
11759             {
11760               nzero_counts += counts[i] * i;
11761               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11762                       i, counts[i], (counts[i] * 100.0) / nbuckets,
11763                       (nzero_counts * 100.0) / nsyms);
11764             }
11765         }
11766
11767       free (counts);
11768       free (lengths);
11769     }
11770
11771   if (buckets != NULL)
11772     {
11773       free (buckets);
11774       free (chains);
11775     }
11776
11777   if (do_histogram && gnubuckets != NULL)
11778     {
11779       unsigned long * lengths;
11780       unsigned long * counts;
11781       unsigned long hn;
11782       unsigned long maxlength = 0;
11783       unsigned long nzero_counts = 0;
11784       unsigned long nsyms = 0;
11785
11786       printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11787                         "(total of %lu bucket):\n",
11788                         "\nHistogram for `.gnu.hash' bucket list length "
11789                         "(total of %lu buckets):\n",
11790                         (unsigned long) ngnubuckets),
11791               (unsigned long) ngnubuckets);
11792
11793       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11794       if (lengths == NULL)
11795         {
11796           error (_("Out of memory allocating space for gnu histogram buckets\n"));
11797           return FALSE;
11798         }
11799
11800       printf (_(" Length  Number     %% of total  Coverage\n"));
11801
11802       for (hn = 0; hn < ngnubuckets; ++hn)
11803         if (gnubuckets[hn] != 0)
11804           {
11805             bfd_vma off, length = 1;
11806
11807             for (off = gnubuckets[hn] - gnusymidx;
11808                  /* PR 17531 file: 010-77222-0.004.  */
11809                  off < ngnuchains && (gnuchains[off] & 1) == 0;
11810                  ++off)
11811               ++length;
11812             lengths[hn] = length;
11813             if (length > maxlength)
11814               maxlength = length;
11815             nsyms += length;
11816           }
11817
11818       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11819       if (counts == NULL)
11820         {
11821           free (lengths);
11822           error (_("Out of memory allocating space for gnu histogram counts\n"));
11823           return FALSE;
11824         }
11825
11826       for (hn = 0; hn < ngnubuckets; ++hn)
11827         ++counts[lengths[hn]];
11828
11829       if (ngnubuckets > 0)
11830         {
11831           unsigned long j;
11832           printf ("      0  %-10lu (%5.1f%%)\n",
11833                   counts[0], (counts[0] * 100.0) / ngnubuckets);
11834           for (j = 1; j <= maxlength; ++j)
11835             {
11836               nzero_counts += counts[j] * j;
11837               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11838                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11839                       (nzero_counts * 100.0) / nsyms);
11840             }
11841         }
11842
11843       free (counts);
11844       free (lengths);
11845       free (gnubuckets);
11846       free (gnuchains);
11847     }
11848
11849   return TRUE;
11850 }
11851
11852 static bfd_boolean
11853 process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
11854 {
11855   unsigned int i;
11856
11857   if (dynamic_syminfo == NULL
11858       || !do_dynamic)
11859     /* No syminfo, this is ok.  */
11860     return TRUE;
11861
11862   /* There better should be a dynamic symbol section.  */
11863   if (dynamic_symbols == NULL || dynamic_strings == NULL)
11864     return FALSE;
11865
11866   if (dynamic_addr)
11867     printf (ngettext ("\nDynamic info segment at offset 0x%lx "
11868                       "contains %d entry:\n",
11869                       "\nDynamic info segment at offset 0x%lx "
11870                       "contains %d entries:\n",
11871                       dynamic_syminfo_nent),
11872             dynamic_syminfo_offset, dynamic_syminfo_nent);
11873
11874   printf (_(" Num: Name                           BoundTo     Flags\n"));
11875   for (i = 0; i < dynamic_syminfo_nent; ++i)
11876     {
11877       unsigned short int flags = dynamic_syminfo[i].si_flags;
11878
11879       printf ("%4d: ", i);
11880       if (i >= num_dynamic_syms)
11881         printf (_("<corrupt index>"));
11882       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
11883         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11884       else
11885         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
11886       putchar (' ');
11887
11888       switch (dynamic_syminfo[i].si_boundto)
11889         {
11890         case SYMINFO_BT_SELF:
11891           fputs ("SELF       ", stdout);
11892           break;
11893         case SYMINFO_BT_PARENT:
11894           fputs ("PARENT     ", stdout);
11895           break;
11896         default:
11897           if (dynamic_syminfo[i].si_boundto > 0
11898               && dynamic_syminfo[i].si_boundto < dynamic_nent
11899               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
11900             {
11901               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
11902               putchar (' ' );
11903             }
11904           else
11905             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11906           break;
11907         }
11908
11909       if (flags & SYMINFO_FLG_DIRECT)
11910         printf (" DIRECT");
11911       if (flags & SYMINFO_FLG_PASSTHRU)
11912         printf (" PASSTHRU");
11913       if (flags & SYMINFO_FLG_COPY)
11914         printf (" COPY");
11915       if (flags & SYMINFO_FLG_LAZYLOAD)
11916         printf (" LAZYLOAD");
11917
11918       puts ("");
11919     }
11920
11921   return TRUE;
11922 }
11923
11924 #define IN_RANGE(START,END,ADDR,OFF)            \
11925   (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11926
11927 /* Check to see if the given reloc needs to be handled in a target specific
11928    manner.  If so then process the reloc and return TRUE otherwise return
11929    FALSE.
11930
11931    If called with reloc == NULL, then this is a signal that reloc processing
11932    for the current section has finished, and any saved state should be
11933    discarded.  */
11934
11935 static bfd_boolean
11936 target_specific_reloc_handling (Filedata *           filedata,
11937                                 Elf_Internal_Rela *  reloc,
11938                                 unsigned char *      start,
11939                                 unsigned char *      end,
11940                                 Elf_Internal_Sym *   symtab,
11941                                 unsigned long        num_syms)
11942 {
11943   unsigned int reloc_type = 0;
11944   unsigned long sym_index = 0;
11945
11946   if (reloc)
11947     {
11948       reloc_type = get_reloc_type (filedata, reloc->r_info);
11949       sym_index = get_reloc_symindex (reloc->r_info);
11950     }
11951
11952   switch (filedata->file_header.e_machine)
11953     {
11954     case EM_MSP430:
11955     case EM_MSP430_OLD:
11956       {
11957         static Elf_Internal_Sym * saved_sym = NULL;
11958
11959         if (reloc == NULL)
11960           {
11961             saved_sym = NULL;
11962             return TRUE;
11963           }
11964
11965         switch (reloc_type)
11966           {
11967           case 10: /* R_MSP430_SYM_DIFF */
11968             if (uses_msp430x_relocs (filedata))
11969               break;
11970             /* Fall through.  */
11971           case 21: /* R_MSP430X_SYM_DIFF */
11972             /* PR 21139.  */
11973             if (sym_index >= num_syms)
11974               error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11975                      sym_index);
11976             else
11977               saved_sym = symtab + sym_index;
11978             return TRUE;
11979
11980           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11981           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11982             goto handle_sym_diff;
11983
11984           case 5: /* R_MSP430_16_BYTE */
11985           case 9: /* R_MSP430_8 */
11986             if (uses_msp430x_relocs (filedata))
11987               break;
11988             goto handle_sym_diff;
11989
11990           case 2: /* R_MSP430_ABS16 */
11991           case 15: /* R_MSP430X_ABS16 */
11992             if (! uses_msp430x_relocs (filedata))
11993               break;
11994             goto handle_sym_diff;
11995
11996           handle_sym_diff:
11997             if (saved_sym != NULL)
11998               {
11999                 int reloc_size = reloc_type == 1 ? 4 : 2;
12000                 bfd_vma value;
12001
12002                 if (sym_index >= num_syms)
12003                   error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12004                          sym_index);
12005                 else
12006                   {
12007                     value = reloc->r_addend + (symtab[sym_index].st_value
12008                                                - saved_sym->st_value);
12009
12010                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12011                       byte_put (start + reloc->r_offset, value, reloc_size);
12012                     else
12013                       /* PR 21137 */
12014                       error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12015                              (long) reloc->r_offset);
12016                   }
12017
12018                 saved_sym = NULL;
12019                 return TRUE;
12020               }
12021             break;
12022
12023           default:
12024             if (saved_sym != NULL)
12025               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12026             break;
12027           }
12028         break;
12029       }
12030
12031     case EM_MN10300:
12032     case EM_CYGNUS_MN10300:
12033       {
12034         static Elf_Internal_Sym * saved_sym = NULL;
12035
12036         if (reloc == NULL)
12037           {
12038             saved_sym = NULL;
12039             return TRUE;
12040           }
12041
12042         switch (reloc_type)
12043           {
12044           case 34: /* R_MN10300_ALIGN */
12045             return TRUE;
12046           case 33: /* R_MN10300_SYM_DIFF */
12047             if (sym_index >= num_syms)
12048               error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12049                      sym_index);
12050             else
12051               saved_sym = symtab + sym_index;
12052             return TRUE;
12053
12054           case 1: /* R_MN10300_32 */
12055           case 2: /* R_MN10300_16 */
12056             if (saved_sym != NULL)
12057               {
12058                 int reloc_size = reloc_type == 1 ? 4 : 2;
12059                 bfd_vma value;
12060
12061                 if (sym_index >= num_syms)
12062                   error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12063                          sym_index);
12064                 else
12065                   {
12066                     value = reloc->r_addend + (symtab[sym_index].st_value
12067                                                - saved_sym->st_value);
12068
12069                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12070                       byte_put (start + reloc->r_offset, value, reloc_size);
12071                     else
12072                       error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12073                              (long) reloc->r_offset);
12074                   }
12075
12076                 saved_sym = NULL;
12077                 return TRUE;
12078               }
12079             break;
12080           default:
12081             if (saved_sym != NULL)
12082               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12083             break;
12084           }
12085         break;
12086       }
12087
12088     case EM_RL78:
12089       {
12090         static bfd_vma saved_sym1 = 0;
12091         static bfd_vma saved_sym2 = 0;
12092         static bfd_vma value;
12093
12094         if (reloc == NULL)
12095           {
12096             saved_sym1 = saved_sym2 = 0;
12097             return TRUE;
12098           }
12099
12100         switch (reloc_type)
12101           {
12102           case 0x80: /* R_RL78_SYM.  */
12103             saved_sym1 = saved_sym2;
12104             if (sym_index >= num_syms)
12105               error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12106                      sym_index);
12107             else
12108               {
12109                 saved_sym2 = symtab[sym_index].st_value;
12110                 saved_sym2 += reloc->r_addend;
12111               }
12112             return TRUE;
12113
12114           case 0x83: /* R_RL78_OPsub.  */
12115             value = saved_sym1 - saved_sym2;
12116             saved_sym2 = saved_sym1 = 0;
12117             return TRUE;
12118             break;
12119
12120           case 0x41: /* R_RL78_ABS32.  */
12121             if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12122               byte_put (start + reloc->r_offset, value, 4);
12123             else
12124               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12125                      (long) reloc->r_offset);
12126             value = 0;
12127             return TRUE;
12128
12129           case 0x43: /* R_RL78_ABS16.  */
12130             if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12131               byte_put (start + reloc->r_offset, value, 2);
12132             else
12133               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12134                      (long) reloc->r_offset);
12135             value = 0;
12136             return TRUE;
12137
12138           default:
12139             break;
12140           }
12141         break;
12142       }
12143     }
12144
12145   return FALSE;
12146 }
12147
12148 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12149    DWARF debug sections.  This is a target specific test.  Note - we do not
12150    go through the whole including-target-headers-multiple-times route, (as
12151    we have already done with <elf/h8.h>) because this would become very
12152    messy and even then this function would have to contain target specific
12153    information (the names of the relocs instead of their numeric values).
12154    FIXME: This is not the correct way to solve this problem.  The proper way
12155    is to have target specific reloc sizing and typing functions created by
12156    the reloc-macros.h header, in the same way that it already creates the
12157    reloc naming functions.  */
12158
12159 static bfd_boolean
12160 is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12161 {
12162   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12163   switch (filedata->file_header.e_machine)
12164     {
12165     case EM_386:
12166     case EM_IAMCU:
12167       return reloc_type == 1; /* R_386_32.  */
12168     case EM_68K:
12169       return reloc_type == 1; /* R_68K_32.  */
12170     case EM_860:
12171       return reloc_type == 1; /* R_860_32.  */
12172     case EM_960:
12173       return reloc_type == 2; /* R_960_32.  */
12174     case EM_AARCH64:
12175       return (reloc_type == 258
12176               || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12177     case EM_ADAPTEVA_EPIPHANY:
12178       return reloc_type == 3;
12179     case EM_ALPHA:
12180       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
12181     case EM_ARC:
12182       return reloc_type == 1; /* R_ARC_32.  */
12183     case EM_ARC_COMPACT:
12184     case EM_ARC_COMPACT2:
12185       return reloc_type == 4; /* R_ARC_32.  */
12186     case EM_ARM:
12187       return reloc_type == 2; /* R_ARM_ABS32 */
12188     case EM_AVR_OLD:
12189     case EM_AVR:
12190       return reloc_type == 1;
12191     case EM_BLACKFIN:
12192       return reloc_type == 0x12; /* R_byte4_data.  */
12193     case EM_CRIS:
12194       return reloc_type == 3; /* R_CRIS_32.  */
12195     case EM_CR16:
12196       return reloc_type == 3; /* R_CR16_NUM32.  */
12197     case EM_CRX:
12198       return reloc_type == 15; /* R_CRX_NUM32.  */
12199     case EM_CYGNUS_FRV:
12200       return reloc_type == 1;
12201     case EM_CYGNUS_D10V:
12202     case EM_D10V:
12203       return reloc_type == 6; /* R_D10V_32.  */
12204     case EM_CYGNUS_D30V:
12205     case EM_D30V:
12206       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
12207     case EM_DLX:
12208       return reloc_type == 3; /* R_DLX_RELOC_32.  */
12209     case EM_CYGNUS_FR30:
12210     case EM_FR30:
12211       return reloc_type == 3; /* R_FR30_32.  */
12212     case EM_FT32:
12213       return reloc_type == 1; /* R_FT32_32.  */
12214     case EM_H8S:
12215     case EM_H8_300:
12216     case EM_H8_300H:
12217       return reloc_type == 1; /* R_H8_DIR32.  */
12218     case EM_IA_64:
12219       return (reloc_type == 0x64    /* R_IA64_SECREL32MSB.  */
12220               || reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
12221               || reloc_type == 0x24 /* R_IA64_DIR32MSB.  */
12222               || reloc_type == 0x25 /* R_IA64_DIR32LSB.  */);
12223     case EM_IP2K_OLD:
12224     case EM_IP2K:
12225       return reloc_type == 2; /* R_IP2K_32.  */
12226     case EM_IQ2000:
12227       return reloc_type == 2; /* R_IQ2000_32.  */
12228     case EM_LATTICEMICO32:
12229       return reloc_type == 3; /* R_LM32_32.  */
12230     case EM_M32C_OLD:
12231     case EM_M32C:
12232       return reloc_type == 3; /* R_M32C_32.  */
12233     case EM_M32R:
12234       return reloc_type == 34; /* R_M32R_32_RELA.  */
12235     case EM_68HC11:
12236     case EM_68HC12:
12237       return reloc_type == 6; /* R_M68HC11_32.  */
12238     case EM_MCORE:
12239       return reloc_type == 1; /* R_MCORE_ADDR32.  */
12240     case EM_CYGNUS_MEP:
12241       return reloc_type == 4; /* R_MEP_32.  */
12242     case EM_METAG:
12243       return reloc_type == 2; /* R_METAG_ADDR32.  */
12244     case EM_MICROBLAZE:
12245       return reloc_type == 1; /* R_MICROBLAZE_32.  */
12246     case EM_MIPS:
12247       return reloc_type == 2; /* R_MIPS_32.  */
12248     case EM_MMIX:
12249       return reloc_type == 4; /* R_MMIX_32.  */
12250     case EM_CYGNUS_MN10200:
12251     case EM_MN10200:
12252       return reloc_type == 1; /* R_MN10200_32.  */
12253     case EM_CYGNUS_MN10300:
12254     case EM_MN10300:
12255       return reloc_type == 1; /* R_MN10300_32.  */
12256     case EM_MOXIE:
12257       return reloc_type == 1; /* R_MOXIE_32.  */
12258     case EM_MSP430_OLD:
12259     case EM_MSP430:
12260       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
12261     case EM_MT:
12262       return reloc_type == 2; /* R_MT_32.  */
12263     case EM_NDS32:
12264       return reloc_type == 20; /* R_NDS32_RELA.  */
12265     case EM_ALTERA_NIOS2:
12266       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
12267     case EM_NIOS32:
12268       return reloc_type == 1; /* R_NIOS_32.  */
12269     case EM_OR1K:
12270       return reloc_type == 1; /* R_OR1K_32.  */
12271     case EM_PARISC:
12272       return (reloc_type == 1 /* R_PARISC_DIR32.  */
12273               || reloc_type == 41); /* R_PARISC_SECREL32.  */
12274     case EM_PJ:
12275     case EM_PJ_OLD:
12276       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
12277     case EM_PPC64:
12278       return reloc_type == 1; /* R_PPC64_ADDR32.  */
12279     case EM_PPC:
12280       return reloc_type == 1; /* R_PPC_ADDR32.  */
12281     case EM_TI_PRU:
12282       return reloc_type == 11; /* R_PRU_BFD_RELOC_32.  */
12283     case EM_RISCV:
12284       return reloc_type == 1; /* R_RISCV_32.  */
12285     case EM_RL78:
12286       return reloc_type == 1; /* R_RL78_DIR32.  */
12287     case EM_RX:
12288       return reloc_type == 1; /* R_RX_DIR32.  */
12289     case EM_S370:
12290       return reloc_type == 1; /* R_I370_ADDR31.  */
12291     case EM_S390_OLD:
12292     case EM_S390:
12293       return reloc_type == 4; /* R_S390_32.  */
12294     case EM_SCORE:
12295       return reloc_type == 8; /* R_SCORE_ABS32.  */
12296     case EM_SH:
12297       return reloc_type == 1; /* R_SH_DIR32.  */
12298     case EM_SPARC32PLUS:
12299     case EM_SPARCV9:
12300     case EM_SPARC:
12301       return reloc_type == 3 /* R_SPARC_32.  */
12302         || reloc_type == 23; /* R_SPARC_UA32.  */
12303     case EM_SPU:
12304       return reloc_type == 6; /* R_SPU_ADDR32 */
12305     case EM_TI_C6000:
12306       return reloc_type == 1; /* R_C6000_ABS32.  */
12307     case EM_TILEGX:
12308       return reloc_type == 2; /* R_TILEGX_32.  */
12309     case EM_TILEPRO:
12310       return reloc_type == 1; /* R_TILEPRO_32.  */
12311     case EM_CYGNUS_V850:
12312     case EM_V850:
12313       return reloc_type == 6; /* R_V850_ABS32.  */
12314     case EM_V800:
12315       return reloc_type == 0x33; /* R_V810_WORD.  */
12316     case EM_VAX:
12317       return reloc_type == 1; /* R_VAX_32.  */
12318     case EM_VISIUM:
12319       return reloc_type == 3;  /* R_VISIUM_32. */
12320     case EM_WEBASSEMBLY:
12321       return reloc_type == 1;  /* R_WASM32_32.  */
12322     case EM_X86_64:
12323     case EM_L1OM:
12324     case EM_K1OM:
12325       return reloc_type == 10; /* R_X86_64_32.  */
12326     case EM_XC16X:
12327     case EM_C166:
12328       return reloc_type == 3; /* R_XC16C_ABS_32.  */
12329     case EM_XGATE:
12330       return reloc_type == 4; /* R_XGATE_32.  */
12331     case EM_XSTORMY16:
12332       return reloc_type == 1; /* R_XSTROMY16_32.  */
12333     case EM_XTENSA_OLD:
12334     case EM_XTENSA:
12335       return reloc_type == 1; /* R_XTENSA_32.  */
12336     default:
12337       {
12338         static unsigned int prev_warn = 0;
12339
12340         /* Avoid repeating the same warning multiple times.  */
12341         if (prev_warn != filedata->file_header.e_machine)
12342           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12343                  filedata->file_header.e_machine);
12344         prev_warn = filedata->file_header.e_machine;
12345         return FALSE;
12346       }
12347     }
12348 }
12349
12350 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12351    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
12352
12353 static bfd_boolean
12354 is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12355 {
12356   switch (filedata->file_header.e_machine)
12357   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12358     {
12359     case EM_386:
12360     case EM_IAMCU:
12361       return reloc_type == 2;  /* R_386_PC32.  */
12362     case EM_68K:
12363       return reloc_type == 4;  /* R_68K_PC32.  */
12364     case EM_AARCH64:
12365       return reloc_type == 261; /* R_AARCH64_PREL32 */
12366     case EM_ADAPTEVA_EPIPHANY:
12367       return reloc_type == 6;
12368     case EM_ALPHA:
12369       return reloc_type == 10; /* R_ALPHA_SREL32.  */
12370     case EM_ARC_COMPACT:
12371     case EM_ARC_COMPACT2:
12372       return reloc_type == 49; /* R_ARC_32_PCREL.  */
12373     case EM_ARM:
12374       return reloc_type == 3;  /* R_ARM_REL32 */
12375     case EM_AVR_OLD:
12376     case EM_AVR:
12377       return reloc_type == 36; /* R_AVR_32_PCREL.  */
12378     case EM_MICROBLAZE:
12379       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
12380     case EM_OR1K:
12381       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
12382     case EM_PARISC:
12383       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
12384     case EM_PPC:
12385       return reloc_type == 26; /* R_PPC_REL32.  */
12386     case EM_PPC64:
12387       return reloc_type == 26; /* R_PPC64_REL32.  */
12388     case EM_S390_OLD:
12389     case EM_S390:
12390       return reloc_type == 5;  /* R_390_PC32.  */
12391     case EM_SH:
12392       return reloc_type == 2;  /* R_SH_REL32.  */
12393     case EM_SPARC32PLUS:
12394     case EM_SPARCV9:
12395     case EM_SPARC:
12396       return reloc_type == 6;  /* R_SPARC_DISP32.  */
12397     case EM_SPU:
12398       return reloc_type == 13; /* R_SPU_REL32.  */
12399     case EM_TILEGX:
12400       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
12401     case EM_TILEPRO:
12402       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
12403     case EM_VISIUM:
12404       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
12405     case EM_X86_64:
12406     case EM_L1OM:
12407     case EM_K1OM:
12408       return reloc_type == 2;  /* R_X86_64_PC32.  */
12409     case EM_XTENSA_OLD:
12410     case EM_XTENSA:
12411       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
12412     default:
12413       /* Do not abort or issue an error message here.  Not all targets use
12414          pc-relative 32-bit relocs in their DWARF debug information and we
12415          have already tested for target coverage in is_32bit_abs_reloc.  A
12416          more helpful warning message will be generated by apply_relocations
12417          anyway, so just return.  */
12418       return FALSE;
12419     }
12420 }
12421
12422 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12423    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
12424
12425 static bfd_boolean
12426 is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12427 {
12428   switch (filedata->file_header.e_machine)
12429     {
12430     case EM_AARCH64:
12431       return reloc_type == 257; /* R_AARCH64_ABS64.  */
12432     case EM_ALPHA:
12433       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
12434     case EM_IA_64:
12435       return (reloc_type == 0x26    /* R_IA64_DIR64MSB.  */
12436               || reloc_type == 0x27 /* R_IA64_DIR64LSB.  */);
12437     case EM_PARISC:
12438       return reloc_type == 80; /* R_PARISC_DIR64.  */
12439     case EM_PPC64:
12440       return reloc_type == 38; /* R_PPC64_ADDR64.  */
12441     case EM_RISCV:
12442       return reloc_type == 2; /* R_RISCV_64.  */
12443     case EM_SPARC32PLUS:
12444     case EM_SPARCV9:
12445     case EM_SPARC:
12446       return reloc_type == 32 /* R_SPARC_64.  */
12447         || reloc_type == 54; /* R_SPARC_UA64.  */
12448     case EM_X86_64:
12449     case EM_L1OM:
12450     case EM_K1OM:
12451       return reloc_type == 1; /* R_X86_64_64.  */
12452     case EM_S390_OLD:
12453     case EM_S390:
12454       return reloc_type == 22;  /* R_S390_64.  */
12455     case EM_TILEGX:
12456       return reloc_type == 1; /* R_TILEGX_64.  */
12457     case EM_MIPS:
12458       return reloc_type == 18;  /* R_MIPS_64.  */
12459     default:
12460       return FALSE;
12461     }
12462 }
12463
12464 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12465    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
12466
12467 static bfd_boolean
12468 is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12469 {
12470   switch (filedata->file_header.e_machine)
12471     {
12472     case EM_AARCH64:
12473       return reloc_type == 260; /* R_AARCH64_PREL64.  */
12474     case EM_ALPHA:
12475       return reloc_type == 11; /* R_ALPHA_SREL64.  */
12476     case EM_IA_64:
12477       return (reloc_type == 0x4e    /* R_IA64_PCREL64MSB.  */
12478               || reloc_type == 0x4f /* R_IA64_PCREL64LSB.  */);
12479     case EM_PARISC:
12480       return reloc_type == 72; /* R_PARISC_PCREL64.  */
12481     case EM_PPC64:
12482       return reloc_type == 44; /* R_PPC64_REL64.  */
12483     case EM_SPARC32PLUS:
12484     case EM_SPARCV9:
12485     case EM_SPARC:
12486       return reloc_type == 46; /* R_SPARC_DISP64.  */
12487     case EM_X86_64:
12488     case EM_L1OM:
12489     case EM_K1OM:
12490       return reloc_type == 24; /* R_X86_64_PC64.  */
12491     case EM_S390_OLD:
12492     case EM_S390:
12493       return reloc_type == 23;  /* R_S390_PC64.  */
12494     case EM_TILEGX:
12495       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
12496     default:
12497       return FALSE;
12498     }
12499 }
12500
12501 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12502    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
12503
12504 static bfd_boolean
12505 is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12506 {
12507   switch (filedata->file_header.e_machine)
12508     {
12509     case EM_CYGNUS_MN10200:
12510     case EM_MN10200:
12511       return reloc_type == 4; /* R_MN10200_24.  */
12512     case EM_FT32:
12513       return reloc_type == 5; /* R_FT32_20.  */
12514     default:
12515       return FALSE;
12516     }
12517 }
12518
12519 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12520    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
12521
12522 static bfd_boolean
12523 is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12524 {
12525   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12526   switch (filedata->file_header.e_machine)
12527     {
12528     case EM_ARC:
12529     case EM_ARC_COMPACT:
12530     case EM_ARC_COMPACT2:
12531       return reloc_type == 2; /* R_ARC_16.  */
12532     case EM_ADAPTEVA_EPIPHANY:
12533       return reloc_type == 5;
12534     case EM_AVR_OLD:
12535     case EM_AVR:
12536       return reloc_type == 4; /* R_AVR_16.  */
12537     case EM_CYGNUS_D10V:
12538     case EM_D10V:
12539       return reloc_type == 3; /* R_D10V_16.  */
12540     case EM_FT32:
12541       return reloc_type == 2; /* R_FT32_16.  */
12542     case EM_H8S:
12543     case EM_H8_300:
12544     case EM_H8_300H:
12545       return reloc_type == R_H8_DIR16;
12546     case EM_IP2K_OLD:
12547     case EM_IP2K:
12548       return reloc_type == 1; /* R_IP2K_16.  */
12549     case EM_M32C_OLD:
12550     case EM_M32C:
12551       return reloc_type == 1; /* R_M32C_16 */
12552     case EM_CYGNUS_MN10200:
12553     case EM_MN10200:
12554       return reloc_type == 2; /* R_MN10200_16.  */
12555     case EM_CYGNUS_MN10300:
12556     case EM_MN10300:
12557       return reloc_type == 2; /* R_MN10300_16.  */
12558     case EM_MSP430:
12559       if (uses_msp430x_relocs (filedata))
12560         return reloc_type == 2; /* R_MSP430_ABS16.  */
12561       /* Fall through.  */
12562     case EM_MSP430_OLD:
12563       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
12564     case EM_NDS32:
12565       return reloc_type == 19; /* R_NDS32_RELA.  */
12566     case EM_ALTERA_NIOS2:
12567       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
12568     case EM_NIOS32:
12569       return reloc_type == 9; /* R_NIOS_16.  */
12570     case EM_OR1K:
12571       return reloc_type == 2; /* R_OR1K_16.  */
12572     case EM_TI_PRU:
12573       return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
12574     case EM_TI_C6000:
12575       return reloc_type == 2; /* R_C6000_ABS16.  */
12576     case EM_VISIUM:
12577       return reloc_type == 2; /* R_VISIUM_16. */
12578     case EM_XC16X:
12579     case EM_C166:
12580       return reloc_type == 2; /* R_XC16C_ABS_16.  */
12581     case EM_XGATE:
12582       return reloc_type == 3; /* R_XGATE_16.  */
12583     default:
12584       return FALSE;
12585     }
12586 }
12587
12588 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12589    a 32-bit inplace add RELA relocation used in DWARF debug sections.  */
12590
12591 static bfd_boolean
12592 is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12593 {
12594   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12595   switch (filedata->file_header.e_machine)
12596     {
12597     case EM_RISCV:
12598       return reloc_type == 35; /* R_RISCV_ADD32.  */
12599     default:
12600       return FALSE;
12601     }
12602 }
12603
12604 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12605    a 32-bit inplace sub RELA relocation used in DWARF debug sections.  */
12606
12607 static bfd_boolean
12608 is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12609 {
12610   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12611   switch (filedata->file_header.e_machine)
12612     {
12613     case EM_RISCV:
12614       return reloc_type == 39; /* R_RISCV_SUB32.  */
12615     default:
12616       return FALSE;
12617     }
12618 }
12619
12620 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12621    a 64-bit inplace add RELA relocation used in DWARF debug sections.  */
12622
12623 static bfd_boolean
12624 is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12625 {
12626   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12627   switch (filedata->file_header.e_machine)
12628     {
12629     case EM_RISCV:
12630       return reloc_type == 36; /* R_RISCV_ADD64.  */
12631     default:
12632       return FALSE;
12633     }
12634 }
12635
12636 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12637    a 64-bit inplace sub RELA relocation used in DWARF debug sections.  */
12638
12639 static bfd_boolean
12640 is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12641 {
12642   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12643   switch (filedata->file_header.e_machine)
12644     {
12645     case EM_RISCV:
12646       return reloc_type == 40; /* R_RISCV_SUB64.  */
12647     default:
12648       return FALSE;
12649     }
12650 }
12651
12652 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12653    a 16-bit inplace add RELA relocation used in DWARF debug sections.  */
12654
12655 static bfd_boolean
12656 is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12657 {
12658   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12659   switch (filedata->file_header.e_machine)
12660     {
12661     case EM_RISCV:
12662       return reloc_type == 34; /* R_RISCV_ADD16.  */
12663     default:
12664       return FALSE;
12665     }
12666 }
12667
12668 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12669    a 16-bit inplace sub RELA relocation used in DWARF debug sections.  */
12670
12671 static bfd_boolean
12672 is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12673 {
12674   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12675   switch (filedata->file_header.e_machine)
12676     {
12677     case EM_RISCV:
12678       return reloc_type == 38; /* R_RISCV_SUB16.  */
12679     default:
12680       return FALSE;
12681     }
12682 }
12683
12684 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12685    a 8-bit inplace add RELA relocation used in DWARF debug sections.  */
12686
12687 static bfd_boolean
12688 is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12689 {
12690   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12691   switch (filedata->file_header.e_machine)
12692     {
12693     case EM_RISCV:
12694       return reloc_type == 33; /* R_RISCV_ADD8.  */
12695     default:
12696       return FALSE;
12697     }
12698 }
12699
12700 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12701    a 8-bit inplace sub RELA relocation used in DWARF debug sections.  */
12702
12703 static bfd_boolean
12704 is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12705 {
12706   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12707   switch (filedata->file_header.e_machine)
12708     {
12709     case EM_RISCV:
12710       return reloc_type == 37; /* R_RISCV_SUB8.  */
12711     default:
12712       return FALSE;
12713     }
12714 }
12715
12716 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12717    relocation entries (possibly formerly used for SHT_GROUP sections).  */
12718
12719 static bfd_boolean
12720 is_none_reloc (Filedata * filedata, unsigned int reloc_type)
12721 {
12722   switch (filedata->file_header.e_machine)
12723     {
12724     case EM_386:     /* R_386_NONE.  */
12725     case EM_68K:     /* R_68K_NONE.  */
12726     case EM_ADAPTEVA_EPIPHANY:
12727     case EM_ALPHA:   /* R_ALPHA_NONE.  */
12728     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
12729     case EM_ARC:     /* R_ARC_NONE.  */
12730     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
12731     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
12732     case EM_ARM:     /* R_ARM_NONE.  */
12733     case EM_C166:    /* R_XC16X_NONE.  */
12734     case EM_CRIS:    /* R_CRIS_NONE.  */
12735     case EM_FT32:    /* R_FT32_NONE.  */
12736     case EM_IA_64:   /* R_IA64_NONE.  */
12737     case EM_K1OM:    /* R_X86_64_NONE.  */
12738     case EM_L1OM:    /* R_X86_64_NONE.  */
12739     case EM_M32R:    /* R_M32R_NONE.  */
12740     case EM_MIPS:    /* R_MIPS_NONE.  */
12741     case EM_MN10300: /* R_MN10300_NONE.  */
12742     case EM_MOXIE:   /* R_MOXIE_NONE.  */
12743     case EM_NIOS32:  /* R_NIOS_NONE.  */
12744     case EM_OR1K:    /* R_OR1K_NONE. */
12745     case EM_PARISC:  /* R_PARISC_NONE.  */
12746     case EM_PPC64:   /* R_PPC64_NONE.  */
12747     case EM_PPC:     /* R_PPC_NONE.  */
12748     case EM_RISCV:   /* R_RISCV_NONE.  */
12749     case EM_S390:    /* R_390_NONE.  */
12750     case EM_S390_OLD:
12751     case EM_SH:      /* R_SH_NONE.  */
12752     case EM_SPARC32PLUS:
12753     case EM_SPARC:   /* R_SPARC_NONE.  */
12754     case EM_SPARCV9:
12755     case EM_TILEGX:  /* R_TILEGX_NONE.  */
12756     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
12757     case EM_TI_C6000:/* R_C6000_NONE.  */
12758     case EM_X86_64:  /* R_X86_64_NONE.  */
12759     case EM_XC16X:
12760     case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
12761       return reloc_type == 0;
12762
12763     case EM_AARCH64:
12764       return reloc_type == 0 || reloc_type == 256;
12765     case EM_AVR_OLD:
12766     case EM_AVR:
12767       return (reloc_type == 0 /* R_AVR_NONE.  */
12768               || reloc_type == 30 /* R_AVR_DIFF8.  */
12769               || reloc_type == 31 /* R_AVR_DIFF16.  */
12770               || reloc_type == 32 /* R_AVR_DIFF32.  */);
12771     case EM_METAG:
12772       return reloc_type == 3; /* R_METAG_NONE.  */
12773     case EM_NDS32:
12774       return (reloc_type == 0       /* R_XTENSA_NONE.  */
12775               || reloc_type == 204  /* R_NDS32_DIFF8.  */
12776               || reloc_type == 205  /* R_NDS32_DIFF16.  */
12777               || reloc_type == 206  /* R_NDS32_DIFF32.  */
12778               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
12779     case EM_TI_PRU:
12780       return (reloc_type == 0       /* R_PRU_NONE.  */
12781               || reloc_type == 65   /* R_PRU_DIFF8.  */
12782               || reloc_type == 66   /* R_PRU_DIFF16.  */
12783               || reloc_type == 67   /* R_PRU_DIFF32.  */);
12784     case EM_XTENSA_OLD:
12785     case EM_XTENSA:
12786       return (reloc_type == 0      /* R_XTENSA_NONE.  */
12787               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
12788               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
12789               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
12790     }
12791   return FALSE;
12792 }
12793
12794 /* Returns TRUE if there is a relocation against
12795    section NAME at OFFSET bytes.  */
12796
12797 bfd_boolean
12798 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12799 {
12800   Elf_Internal_Rela * relocs;
12801   Elf_Internal_Rela * rp;
12802
12803   if (dsec == NULL || dsec->reloc_info == NULL)
12804     return FALSE;
12805
12806   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
12807
12808   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
12809     if (rp->r_offset == offset)
12810       return TRUE;
12811
12812    return FALSE;
12813 }
12814
12815 /* Apply relocations to a section.
12816    Returns TRUE upon success, FALSE otherwise.
12817    If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12818    It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
12819    will be set to the number of relocs loaded.
12820
12821    Note: So far support has been added only for those relocations
12822    which can be found in debug sections. FIXME: Add support for
12823    more relocations ?  */
12824
12825 static bfd_boolean
12826 apply_relocations (Filedata *                 filedata,
12827                    const Elf_Internal_Shdr *  section,
12828                    unsigned char *            start,
12829                    bfd_size_type              size,
12830                    void **                    relocs_return,
12831                    unsigned long *            num_relocs_return)
12832 {
12833   Elf_Internal_Shdr * relsec;
12834   unsigned char * end = start + size;
12835   bfd_boolean res = TRUE;
12836
12837   if (relocs_return != NULL)
12838     {
12839       * (Elf_Internal_Rela **) relocs_return = NULL;
12840       * num_relocs_return = 0;
12841     }
12842
12843   if (filedata->file_header.e_type != ET_REL)
12844     /* No relocs to apply.  */
12845     return TRUE;
12846
12847   /* Find the reloc section associated with the section.  */
12848   for (relsec = filedata->section_headers;
12849        relsec < filedata->section_headers + filedata->file_header.e_shnum;
12850        ++relsec)
12851     {
12852       bfd_boolean is_rela;
12853       unsigned long num_relocs;
12854       Elf_Internal_Rela * relocs;
12855       Elf_Internal_Rela * rp;
12856       Elf_Internal_Shdr * symsec;
12857       Elf_Internal_Sym * symtab;
12858       unsigned long num_syms;
12859       Elf_Internal_Sym * sym;
12860
12861       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12862           || relsec->sh_info >= filedata->file_header.e_shnum
12863           || filedata->section_headers + relsec->sh_info != section
12864           || relsec->sh_size == 0
12865           || relsec->sh_link >= filedata->file_header.e_shnum)
12866         continue;
12867
12868       is_rela = relsec->sh_type == SHT_RELA;
12869
12870       if (is_rela)
12871         {
12872           if (!slurp_rela_relocs (filedata, relsec->sh_offset,
12873                                   relsec->sh_size, & relocs, & num_relocs))
12874             return FALSE;
12875         }
12876       else
12877         {
12878           if (!slurp_rel_relocs (filedata, relsec->sh_offset,
12879                                  relsec->sh_size, & relocs, & num_relocs))
12880             return FALSE;
12881         }
12882
12883       /* SH uses RELA but uses in place value instead of the addend field.  */
12884       if (filedata->file_header.e_machine == EM_SH)
12885         is_rela = FALSE;
12886
12887       symsec = filedata->section_headers + relsec->sh_link;
12888       if (symsec->sh_type != SHT_SYMTAB
12889           && symsec->sh_type != SHT_DYNSYM)
12890         return FALSE;
12891       symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
12892
12893       for (rp = relocs; rp < relocs + num_relocs; ++rp)
12894         {
12895           bfd_vma         addend;
12896           unsigned int    reloc_type;
12897           unsigned int    reloc_size;
12898           bfd_boolean     reloc_inplace = FALSE;
12899           bfd_boolean     reloc_subtract = FALSE;
12900           unsigned char * rloc;
12901           unsigned long   sym_index;
12902
12903           reloc_type = get_reloc_type (filedata, rp->r_info);
12904
12905           if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
12906             continue;
12907           else if (is_none_reloc (filedata, reloc_type))
12908             continue;
12909           else if (is_32bit_abs_reloc (filedata, reloc_type)
12910                    || is_32bit_pcrel_reloc (filedata, reloc_type))
12911             reloc_size = 4;
12912           else if (is_64bit_abs_reloc (filedata, reloc_type)
12913                    || is_64bit_pcrel_reloc (filedata, reloc_type))
12914             reloc_size = 8;
12915           else if (is_24bit_abs_reloc (filedata, reloc_type))
12916             reloc_size = 3;
12917           else if (is_16bit_abs_reloc (filedata, reloc_type))
12918             reloc_size = 2;
12919           else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
12920                                                                  reloc_type))
12921                    || is_32bit_inplace_add_reloc (filedata, reloc_type))
12922             {
12923               reloc_size = 4;
12924               reloc_inplace = TRUE;
12925             }
12926           else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
12927                                                                  reloc_type))
12928                    || is_64bit_inplace_add_reloc (filedata, reloc_type))
12929             {
12930               reloc_size = 8;
12931               reloc_inplace = TRUE;
12932             }
12933           else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
12934                                                                  reloc_type))
12935                    || is_16bit_inplace_add_reloc (filedata, reloc_type))
12936             {
12937               reloc_size = 2;
12938               reloc_inplace = TRUE;
12939             }
12940           else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
12941                                                                 reloc_type))
12942                    || is_8bit_inplace_add_reloc (filedata, reloc_type))
12943             {
12944               reloc_size = 1;
12945               reloc_inplace = TRUE;
12946             }
12947           else
12948             {
12949               static unsigned int prev_reloc = 0;
12950
12951               if (reloc_type != prev_reloc)
12952                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12953                       reloc_type, printable_section_name (filedata, section));
12954               prev_reloc = reloc_type;
12955               res = FALSE;
12956               continue;
12957             }
12958
12959           rloc = start + rp->r_offset;
12960           if ((rloc + reloc_size) > end || (rloc < start))
12961             {
12962               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12963                     (unsigned long) rp->r_offset,
12964                     printable_section_name (filedata, section));
12965               res = FALSE;
12966               continue;
12967             }
12968
12969           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
12970           if (sym_index >= num_syms)
12971             {
12972               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12973                     sym_index, printable_section_name (filedata, section));
12974               res = FALSE;
12975               continue;
12976             }
12977           sym = symtab + sym_index;
12978
12979           /* If the reloc has a symbol associated with it,
12980              make sure that it is of an appropriate type.
12981
12982              Relocations against symbols without type can happen.
12983              Gcc -feliminate-dwarf2-dups may generate symbols
12984              without type for debug info.
12985
12986              Icc generates relocations against function symbols
12987              instead of local labels.
12988
12989              Relocations against object symbols can happen, eg when
12990              referencing a global array.  For an example of this see
12991              the _clz.o binary in libgcc.a.  */
12992           if (sym != symtab
12993               && ELF_ST_TYPE (sym->st_info) != STT_COMMON
12994               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
12995             {
12996               warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
12997                     get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
12998                     printable_section_name (filedata, relsec),
12999                     (long int)(rp - relocs));
13000               res = FALSE;
13001               continue;
13002             }
13003
13004           addend = 0;
13005           if (is_rela)
13006             addend += rp->r_addend;
13007           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13008              partial_inplace.  */
13009           if (!is_rela
13010               || (filedata->file_header.e_machine == EM_XTENSA
13011                   && reloc_type == 1)
13012               || ((filedata->file_header.e_machine == EM_PJ
13013                    || filedata->file_header.e_machine == EM_PJ_OLD)
13014                   && reloc_type == 1)
13015               || ((filedata->file_header.e_machine == EM_D30V
13016                    || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13017                   && reloc_type == 12)
13018               || reloc_inplace)
13019             addend += byte_get (rloc, reloc_size);
13020
13021           if (is_32bit_pcrel_reloc (filedata, reloc_type)
13022               || is_64bit_pcrel_reloc (filedata, reloc_type))
13023             {
13024               /* On HPPA, all pc-relative relocations are biased by 8.  */
13025               if (filedata->file_header.e_machine == EM_PARISC)
13026                 addend -= 8;
13027               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13028                         reloc_size);
13029             }
13030           else if (reloc_subtract)
13031             byte_put (rloc, addend - sym->st_value, reloc_size);
13032           else
13033             byte_put (rloc, addend + sym->st_value, reloc_size);
13034         }
13035
13036       free (symtab);
13037       /* Let the target specific reloc processing code know that
13038          we have finished with these relocs.  */
13039       target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13040
13041       if (relocs_return)
13042         {
13043           * (Elf_Internal_Rela **) relocs_return = relocs;
13044           * num_relocs_return = num_relocs;
13045         }
13046       else
13047         free (relocs);
13048
13049       break;
13050     }
13051
13052   return res;
13053 }
13054
13055 #ifdef SUPPORT_DISASSEMBLY
13056 static bfd_boolean
13057 disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13058 {
13059   printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13060
13061   /* FIXME: XXX -- to be done --- XXX */
13062
13063   return TRUE;
13064 }
13065 #endif
13066
13067 /* Reads in the contents of SECTION from FILE, returning a pointer
13068    to a malloc'ed buffer or NULL if something went wrong.  */
13069
13070 static char *
13071 get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13072 {
13073   bfd_size_type num_bytes = section->sh_size;
13074
13075   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13076     {
13077       printf (_("Section '%s' has no data to dump.\n"),
13078               printable_section_name (filedata, section));
13079       return NULL;
13080     }
13081
13082   return  (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13083                              _("section contents"));
13084 }
13085
13086 /* Uncompresses a section that was compressed using zlib, in place.  */
13087
13088 static bfd_boolean
13089 uncompress_section_contents (unsigned char **   buffer,
13090                              dwarf_size_type    uncompressed_size,
13091                              dwarf_size_type *  size)
13092 {
13093   dwarf_size_type compressed_size = *size;
13094   unsigned char * compressed_buffer = *buffer;
13095   unsigned char * uncompressed_buffer;
13096   z_stream strm;
13097   int rc;
13098
13099   /* It is possible the section consists of several compressed
13100      buffers concatenated together, so we uncompress in a loop.  */
13101   /* PR 18313: The state field in the z_stream structure is supposed
13102      to be invisible to the user (ie us), but some compilers will
13103      still complain about it being used without initialisation.  So
13104      we first zero the entire z_stream structure and then set the fields
13105      that we need.  */
13106   memset (& strm, 0, sizeof strm);
13107   strm.avail_in = compressed_size;
13108   strm.next_in = (Bytef *) compressed_buffer;
13109   strm.avail_out = uncompressed_size;
13110   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13111
13112   rc = inflateInit (& strm);
13113   while (strm.avail_in > 0)
13114     {
13115       if (rc != Z_OK)
13116         goto fail;
13117       strm.next_out = ((Bytef *) uncompressed_buffer
13118                        + (uncompressed_size - strm.avail_out));
13119       rc = inflate (&strm, Z_FINISH);
13120       if (rc != Z_STREAM_END)
13121         goto fail;
13122       rc = inflateReset (& strm);
13123     }
13124   rc = inflateEnd (& strm);
13125   if (rc != Z_OK
13126       || strm.avail_out != 0)
13127     goto fail;
13128
13129   *buffer = uncompressed_buffer;
13130   *size = uncompressed_size;
13131   return TRUE;
13132
13133  fail:
13134   free (uncompressed_buffer);
13135   /* Indicate decompression failure.  */
13136   *buffer = NULL;
13137   return FALSE;
13138 }
13139
13140 static bfd_boolean
13141 dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13142 {
13143   Elf_Internal_Shdr *  relsec;
13144   bfd_size_type        num_bytes;
13145   unsigned char *      data;
13146   unsigned char *      end;
13147   unsigned char *      real_start;
13148   unsigned char *      start;
13149   bfd_boolean          some_strings_shown;
13150
13151   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13152   if (start == NULL)
13153     /* PR 21820: Do not fail if the section was empty.  */
13154     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13155
13156   num_bytes = section->sh_size;
13157
13158   printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13159
13160   if (decompress_dumps)
13161     {
13162       dwarf_size_type new_size = num_bytes;
13163       dwarf_size_type uncompressed_size = 0;
13164
13165       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13166         {
13167           Elf_Internal_Chdr chdr;
13168           unsigned int compression_header_size
13169             = get_compression_header (& chdr, (unsigned char *) start,
13170                                       num_bytes);
13171
13172           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13173             {
13174               warn (_("section '%s' has unsupported compress type: %d\n"),
13175                     printable_section_name (filedata, section), chdr.ch_type);
13176               return FALSE;
13177             }
13178           else if (chdr.ch_addralign != section->sh_addralign)
13179             {
13180               warn (_("compressed section '%s' is corrupted\n"),
13181                     printable_section_name (filedata, section));
13182               return FALSE;
13183             }
13184           uncompressed_size = chdr.ch_size;
13185           start += compression_header_size;
13186           new_size -= compression_header_size;
13187         }
13188       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13189         {
13190           /* Read the zlib header.  In this case, it should be "ZLIB"
13191              followed by the uncompressed section size, 8 bytes in
13192              big-endian order.  */
13193           uncompressed_size = start[4]; uncompressed_size <<= 8;
13194           uncompressed_size += start[5]; uncompressed_size <<= 8;
13195           uncompressed_size += start[6]; uncompressed_size <<= 8;
13196           uncompressed_size += start[7]; uncompressed_size <<= 8;
13197           uncompressed_size += start[8]; uncompressed_size <<= 8;
13198           uncompressed_size += start[9]; uncompressed_size <<= 8;
13199           uncompressed_size += start[10]; uncompressed_size <<= 8;
13200           uncompressed_size += start[11];
13201           start += 12;
13202           new_size -= 12;
13203         }
13204
13205       if (uncompressed_size)
13206         {
13207           if (uncompress_section_contents (& start,
13208                                            uncompressed_size, & new_size))
13209             num_bytes = new_size;
13210           else
13211             {
13212               error (_("Unable to decompress section %s\n"),
13213                      printable_section_name (filedata, section));
13214               return FALSE;
13215             }
13216         }
13217       else
13218         start = real_start;
13219     }
13220
13221   /* If the section being dumped has relocations against it the user might
13222      be expecting these relocations to have been applied.  Check for this
13223      case and issue a warning message in order to avoid confusion.
13224      FIXME: Maybe we ought to have an option that dumps a section with
13225      relocs applied ?  */
13226   for (relsec = filedata->section_headers;
13227        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13228        ++relsec)
13229     {
13230       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13231           || relsec->sh_info >= filedata->file_header.e_shnum
13232           || filedata->section_headers + relsec->sh_info != section
13233           || relsec->sh_size == 0
13234           || relsec->sh_link >= filedata->file_header.e_shnum)
13235         continue;
13236
13237       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13238       break;
13239     }
13240
13241   data = start;
13242   end  = start + num_bytes;
13243   some_strings_shown = FALSE;
13244
13245   while (data < end)
13246     {
13247       while (!ISPRINT (* data))
13248         if (++ data >= end)
13249           break;
13250
13251       if (data < end)
13252         {
13253           size_t maxlen = end - data;
13254
13255 #ifndef __MSVCRT__
13256           /* PR 11128: Use two separate invocations in order to work
13257              around bugs in the Solaris 8 implementation of printf.  */
13258           printf ("  [%6tx]  ", data - start);
13259 #else
13260           printf ("  [%6Ix]  ", (size_t) (data - start));
13261 #endif
13262           if (maxlen > 0)
13263             {
13264               print_symbol ((int) maxlen, (const char *) data);
13265               putchar ('\n');
13266               data += strnlen ((const char *) data, maxlen);
13267             }
13268           else
13269             {
13270               printf (_("<corrupt>\n"));
13271               data = end;
13272             }
13273           some_strings_shown = TRUE;
13274         }
13275     }
13276
13277   if (! some_strings_shown)
13278     printf (_("  No strings found in this section."));
13279
13280   free (real_start);
13281
13282   putchar ('\n');
13283   return TRUE;
13284 }
13285
13286 static bfd_boolean
13287 dump_section_as_bytes (Elf_Internal_Shdr *  section,
13288                        Filedata *           filedata,
13289                        bfd_boolean          relocate)
13290 {
13291   Elf_Internal_Shdr * relsec;
13292   bfd_size_type       bytes;
13293   bfd_size_type       section_size;
13294   bfd_vma             addr;
13295   unsigned char *     data;
13296   unsigned char *     real_start;
13297   unsigned char *     start;
13298
13299   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13300   if (start == NULL)
13301     /* PR 21820: Do not fail if the section was empty.  */
13302     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13303
13304   section_size = section->sh_size;
13305
13306   printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13307
13308   if (decompress_dumps)
13309     {
13310       dwarf_size_type new_size = section_size;
13311       dwarf_size_type uncompressed_size = 0;
13312
13313       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13314         {
13315           Elf_Internal_Chdr chdr;
13316           unsigned int compression_header_size
13317             = get_compression_header (& chdr, start, section_size);
13318
13319           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13320             {
13321               warn (_("section '%s' has unsupported compress type: %d\n"),
13322                     printable_section_name (filedata, section), chdr.ch_type);
13323               return FALSE;
13324             }
13325           else if (chdr.ch_addralign != section->sh_addralign)
13326             {
13327               warn (_("compressed section '%s' is corrupted\n"),
13328                     printable_section_name (filedata, section));
13329               return FALSE;
13330             }
13331           uncompressed_size = chdr.ch_size;
13332           start += compression_header_size;
13333           new_size -= compression_header_size;
13334         }
13335       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13336         {
13337           /* Read the zlib header.  In this case, it should be "ZLIB"
13338              followed by the uncompressed section size, 8 bytes in
13339              big-endian order.  */
13340           uncompressed_size = start[4]; uncompressed_size <<= 8;
13341           uncompressed_size += start[5]; uncompressed_size <<= 8;
13342           uncompressed_size += start[6]; uncompressed_size <<= 8;
13343           uncompressed_size += start[7]; uncompressed_size <<= 8;
13344           uncompressed_size += start[8]; uncompressed_size <<= 8;
13345           uncompressed_size += start[9]; uncompressed_size <<= 8;
13346           uncompressed_size += start[10]; uncompressed_size <<= 8;
13347           uncompressed_size += start[11];
13348           start += 12;
13349           new_size -= 12;
13350         }
13351
13352       if (uncompressed_size)
13353         {
13354           if (uncompress_section_contents (& start, uncompressed_size,
13355                                            & new_size))
13356             {
13357               section_size = new_size;
13358             }
13359           else
13360             {
13361               error (_("Unable to decompress section %s\n"),
13362                      printable_section_name (filedata, section));
13363               /* FIXME: Print the section anyway ?  */
13364               return FALSE;
13365             }
13366         }
13367       else
13368         start = real_start;
13369     }
13370
13371   if (relocate)
13372     {
13373       if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
13374         return FALSE;
13375     }
13376   else
13377     {
13378       /* If the section being dumped has relocations against it the user might
13379          be expecting these relocations to have been applied.  Check for this
13380          case and issue a warning message in order to avoid confusion.
13381          FIXME: Maybe we ought to have an option that dumps a section with
13382          relocs applied ?  */
13383       for (relsec = filedata->section_headers;
13384            relsec < filedata->section_headers + filedata->file_header.e_shnum;
13385            ++relsec)
13386         {
13387           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13388               || relsec->sh_info >= filedata->file_header.e_shnum
13389               || filedata->section_headers + relsec->sh_info != section
13390               || relsec->sh_size == 0
13391               || relsec->sh_link >= filedata->file_header.e_shnum)
13392             continue;
13393
13394           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13395           break;
13396         }
13397     }
13398
13399   addr = section->sh_addr;
13400   bytes = section_size;
13401   data = start;
13402
13403   while (bytes)
13404     {
13405       int j;
13406       int k;
13407       int lbytes;
13408
13409       lbytes = (bytes > 16 ? 16 : bytes);
13410
13411       printf ("  0x%8.8lx ", (unsigned long) addr);
13412
13413       for (j = 0; j < 16; j++)
13414         {
13415           if (j < lbytes)
13416             printf ("%2.2x", data[j]);
13417           else
13418             printf ("  ");
13419
13420           if ((j & 3) == 3)
13421             printf (" ");
13422         }
13423
13424       for (j = 0; j < lbytes; j++)
13425         {
13426           k = data[j];
13427           if (k >= ' ' && k < 0x7f)
13428             printf ("%c", k);
13429           else
13430             printf (".");
13431         }
13432
13433       putchar ('\n');
13434
13435       data  += lbytes;
13436       addr  += lbytes;
13437       bytes -= lbytes;
13438     }
13439
13440   free (real_start);
13441
13442   putchar ('\n');
13443   return TRUE;
13444 }
13445
13446 static bfd_boolean
13447 load_specific_debug_section (enum dwarf_section_display_enum  debug,
13448                              const Elf_Internal_Shdr *        sec,
13449                              void *                           data)
13450 {
13451   struct dwarf_section * section = &debug_displays [debug].section;
13452   char buf [64];
13453   Filedata * filedata = (Filedata *) data;
13454
13455   if (section->start != NULL)
13456     {
13457       /* If it is already loaded, do nothing.  */
13458       if (streq (section->filename, filedata->file_name))
13459         return TRUE;
13460       free (section->start);
13461     }
13462
13463   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13464   section->address = sec->sh_addr;
13465   section->user_data = NULL;
13466   section->filename = filedata->file_name;
13467   section->start = (unsigned char *) get_data (NULL, filedata,
13468                                                sec->sh_offset, 1,
13469                                                sec->sh_size, buf);
13470   if (section->start == NULL)
13471     section->size = 0;
13472   else
13473     {
13474       unsigned char *start = section->start;
13475       dwarf_size_type size = sec->sh_size;
13476       dwarf_size_type uncompressed_size = 0;
13477
13478       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13479         {
13480           Elf_Internal_Chdr chdr;
13481           unsigned int compression_header_size;
13482
13483           if (size < (is_32bit_elf
13484                       ? sizeof (Elf32_External_Chdr)
13485                       : sizeof (Elf64_External_Chdr)))
13486             {
13487               warn (_("compressed section %s is too small to contain a compression header"),
13488                     section->name);
13489               return FALSE;
13490             }
13491
13492           compression_header_size = get_compression_header (&chdr, start, size);
13493
13494           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13495             {
13496               warn (_("section '%s' has unsupported compress type: %d\n"),
13497                     section->name, chdr.ch_type);
13498               return FALSE;
13499             }
13500           else if (chdr.ch_addralign != sec->sh_addralign)
13501             {
13502               warn (_("compressed section '%s' is corrupted\n"),
13503                     section->name);
13504               return FALSE;
13505             }
13506           uncompressed_size = chdr.ch_size;
13507           start += compression_header_size;
13508           size -= compression_header_size;
13509         }
13510       else if (size > 12 && streq ((char *) start, "ZLIB"))
13511         {
13512           /* Read the zlib header.  In this case, it should be "ZLIB"
13513              followed by the uncompressed section size, 8 bytes in
13514              big-endian order.  */
13515           uncompressed_size = start[4]; uncompressed_size <<= 8;
13516           uncompressed_size += start[5]; uncompressed_size <<= 8;
13517           uncompressed_size += start[6]; uncompressed_size <<= 8;
13518           uncompressed_size += start[7]; uncompressed_size <<= 8;
13519           uncompressed_size += start[8]; uncompressed_size <<= 8;
13520           uncompressed_size += start[9]; uncompressed_size <<= 8;
13521           uncompressed_size += start[10]; uncompressed_size <<= 8;
13522           uncompressed_size += start[11];
13523           start += 12;
13524           size -= 12;
13525         }
13526
13527       if (uncompressed_size)
13528         {
13529           if (uncompress_section_contents (&start, uncompressed_size,
13530                                            &size))
13531             {
13532               /* Free the compressed buffer, update the section buffer
13533                  and the section size if uncompress is successful.  */
13534               free (section->start);
13535               section->start = start;
13536             }
13537           else
13538             {
13539               error (_("Unable to decompress section %s\n"),
13540                      printable_section_name (filedata, sec));
13541               return FALSE;
13542             }
13543         }
13544
13545       section->size = size;
13546     }
13547
13548   if (section->start == NULL)
13549     return FALSE;
13550
13551   if (debug_displays [debug].relocate)
13552     {
13553       if (! apply_relocations (filedata, sec, section->start, section->size,
13554                                & section->reloc_info, & section->num_relocs))
13555         return FALSE;
13556     }
13557   else
13558     {
13559       section->reloc_info = NULL;
13560       section->num_relocs = 0;
13561     }
13562
13563   return TRUE;
13564 }
13565
13566 /* If this is not NULL, load_debug_section will only look for sections
13567    within the list of sections given here.  */
13568 static unsigned int * section_subset = NULL;
13569
13570 bfd_boolean
13571 load_debug_section (enum dwarf_section_display_enum debug, void * data)
13572 {
13573   struct dwarf_section * section = &debug_displays [debug].section;
13574   Elf_Internal_Shdr * sec;
13575   Filedata * filedata = (Filedata *) data;
13576
13577   if (filedata->string_table == NULL)
13578     {
13579       Elf_Internal_Shdr * strs;
13580
13581       /* Read in the string table, so that we have section names to scan.  */
13582       strs = filedata->section_headers + filedata->file_header.e_shstrndx;
13583
13584       if (strs->sh_size != 0)
13585         {
13586           filedata->string_table = (char *) get_data (NULL, filedata, strs->sh_offset,
13587                                                       1, strs->sh_size,
13588                                                       _("string table"));
13589
13590           filedata->string_table_length = filedata->string_table != NULL ? strs->sh_size : 0;
13591         }
13592     }
13593
13594   /* Locate the debug section.  */
13595   sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
13596   if (sec != NULL)
13597     section->name = section->uncompressed_name;
13598   else
13599     {
13600       sec = find_section_in_set (filedata, section->compressed_name, section_subset);
13601       if (sec != NULL)
13602         section->name = section->compressed_name;
13603     }
13604   if (sec == NULL)
13605     return FALSE;
13606
13607   /* If we're loading from a subset of sections, and we've loaded
13608      a section matching this name before, it's likely that it's a
13609      different one.  */
13610   if (section_subset != NULL)
13611     free_debug_section (debug);
13612
13613   return load_specific_debug_section (debug, sec, data);
13614 }
13615
13616 void
13617 free_debug_section (enum dwarf_section_display_enum debug)
13618 {
13619   struct dwarf_section * section = &debug_displays [debug].section;
13620
13621   if (section->start == NULL)
13622     return;
13623
13624   free ((char *) section->start);
13625   section->start = NULL;
13626   section->address = 0;
13627   section->size = 0;
13628 }
13629
13630 static bfd_boolean
13631 display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
13632 {
13633   char * name = SECTION_NAME (section);
13634   const char * print_name = printable_section_name (filedata, section);
13635   bfd_size_type length;
13636   bfd_boolean result = TRUE;
13637   int i;
13638
13639   length = section->sh_size;
13640   if (length == 0)
13641     {
13642       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13643       return TRUE;
13644     }
13645   if (section->sh_type == SHT_NOBITS)
13646     {
13647       /* There is no point in dumping the contents of a debugging section
13648          which has the NOBITS type - the bits in the file will be random.
13649          This can happen when a file containing a .eh_frame section is
13650          stripped with the --only-keep-debug command line option.  */
13651       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13652               print_name);
13653       return FALSE;
13654     }
13655
13656   if (const_strneq (name, ".gnu.linkonce.wi."))
13657     name = ".debug_info";
13658
13659   /* See if we know how to display the contents of this section.  */
13660   for (i = 0; i < max; i++)
13661     if (streq (debug_displays[i].section.uncompressed_name, name)
13662         || (i == line && const_strneq (name, ".debug_line."))
13663         || streq (debug_displays[i].section.compressed_name, name))
13664       {
13665         struct dwarf_section * sec = &debug_displays [i].section;
13666         int secondary = (section != find_section (filedata, name));
13667
13668         if (secondary)
13669           free_debug_section ((enum dwarf_section_display_enum) i);
13670
13671         if (i == line && const_strneq (name, ".debug_line."))
13672           sec->name = name;
13673         else if (streq (sec->uncompressed_name, name))
13674           sec->name = sec->uncompressed_name;
13675         else
13676           sec->name = sec->compressed_name;
13677
13678         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
13679                                          section, filedata))
13680           {
13681             /* If this debug section is part of a CU/TU set in a .dwp file,
13682                restrict load_debug_section to the sections in that set.  */
13683             section_subset = find_cu_tu_set (filedata, shndx);
13684
13685             result &= debug_displays[i].display (sec, filedata);
13686
13687             section_subset = NULL;
13688
13689             if (secondary || (i != info && i != abbrev))
13690               free_debug_section ((enum dwarf_section_display_enum) i);
13691           }
13692
13693         break;
13694       }
13695
13696   if (i == max)
13697     {
13698       printf (_("Unrecognized debug section: %s\n"), print_name);
13699       result = FALSE;
13700     }
13701
13702   return result;
13703 }
13704
13705 /* Set DUMP_SECTS for all sections where dumps were requested
13706    based on section name.  */
13707
13708 static void
13709 initialise_dumps_byname (Filedata * filedata)
13710 {
13711   struct dump_list_entry * cur;
13712
13713   for (cur = dump_sects_byname; cur; cur = cur->next)
13714     {
13715       unsigned int i;
13716       bfd_boolean any = FALSE;
13717
13718       for (i = 0; i < filedata->file_header.e_shnum; i++)
13719         if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
13720           {
13721             request_dump_bynumber (filedata, i, cur->type);
13722             any = TRUE;
13723           }
13724
13725       if (!any)
13726         warn (_("Section '%s' was not dumped because it does not exist!\n"),
13727               cur->name);
13728     }
13729 }
13730
13731 static bfd_boolean
13732 process_section_contents (Filedata * filedata)
13733 {
13734   Elf_Internal_Shdr * section;
13735   unsigned int i;
13736   bfd_boolean res = TRUE;
13737
13738   if (! do_dump)
13739     return TRUE;
13740
13741   initialise_dumps_byname (filedata);
13742
13743   for (i = 0, section = filedata->section_headers;
13744        i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
13745        i++, section++)
13746     {
13747       dump_type dump = filedata->dump_sects[i];
13748
13749 #ifdef SUPPORT_DISASSEMBLY
13750       if (dump & DISASS_DUMP)
13751         {
13752           if (! disassemble_section (section, filedata))
13753             res = FALSE;
13754         }
13755 #endif
13756       if (dump & HEX_DUMP)
13757         {
13758           if (! dump_section_as_bytes (section, filedata, FALSE))
13759             res = FALSE;
13760         }
13761
13762       if (dump & RELOC_DUMP)
13763         {
13764           if (! dump_section_as_bytes (section, filedata, TRUE))
13765             res = FALSE;
13766         }
13767
13768       if (dump & STRING_DUMP)
13769         {
13770           if (! dump_section_as_strings (section, filedata))
13771             res = FALSE;
13772         }
13773
13774       if (dump & DEBUG_DUMP)
13775         {
13776           if (! display_debug_section (i, section, filedata))
13777             res = FALSE;
13778         }
13779     }
13780
13781   /* Check to see if the user requested a
13782      dump of a section that does not exist.  */
13783   while (i < filedata->num_dump_sects)
13784     {
13785       if (filedata->dump_sects[i])
13786         {
13787           warn (_("Section %d was not dumped because it does not exist!\n"), i);
13788           res = FALSE;
13789         }
13790       i++;
13791     }
13792
13793   return res;
13794 }
13795
13796 static void
13797 process_mips_fpe_exception (int mask)
13798 {
13799   if (mask)
13800     {
13801       bfd_boolean first = TRUE;
13802
13803       if (mask & OEX_FPU_INEX)
13804         fputs ("INEX", stdout), first = FALSE;
13805       if (mask & OEX_FPU_UFLO)
13806         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
13807       if (mask & OEX_FPU_OFLO)
13808         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
13809       if (mask & OEX_FPU_DIV0)
13810         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
13811       if (mask & OEX_FPU_INVAL)
13812         printf ("%sINVAL", first ? "" : "|");
13813     }
13814   else
13815     fputs ("0", stdout);
13816 }
13817
13818 /* Display's the value of TAG at location P.  If TAG is
13819    greater than 0 it is assumed to be an unknown tag, and
13820    a message is printed to this effect.  Otherwise it is
13821    assumed that a message has already been printed.
13822
13823    If the bottom bit of TAG is set it assumed to have a
13824    string value, otherwise it is assumed to have an integer
13825    value.
13826
13827    Returns an updated P pointing to the first unread byte
13828    beyond the end of TAG's value.
13829
13830    Reads at or beyond END will not be made.  */
13831
13832 static unsigned char *
13833 display_tag_value (signed int tag,
13834                    unsigned char * p,
13835                    const unsigned char * const end)
13836 {
13837   unsigned long val;
13838
13839   if (tag > 0)
13840     printf ("  Tag_unknown_%d: ", tag);
13841
13842   if (p >= end)
13843     {
13844       warn (_("<corrupt tag>\n"));
13845     }
13846   else if (tag & 1)
13847     {
13848       /* PR 17531 file: 027-19978-0.004.  */
13849       size_t maxlen = (end - p) - 1;
13850
13851       putchar ('"');
13852       if (maxlen > 0)
13853         {
13854           print_symbol ((int) maxlen, (const char *) p);
13855           p += strnlen ((char *) p, maxlen) + 1;
13856         }
13857       else
13858         {
13859           printf (_("<corrupt string tag>"));
13860           p = (unsigned char *) end;
13861         }
13862       printf ("\"\n");
13863     }
13864   else
13865     {
13866       unsigned int len;
13867
13868       val = read_uleb128 (p, &len, end);
13869       p += len;
13870       printf ("%ld (0x%lx)\n", val, val);
13871     }
13872
13873   assert (p <= end);
13874   return p;
13875 }
13876
13877 /* ARC ABI attributes section.  */
13878
13879 static unsigned char *
13880 display_arc_attribute (unsigned char * p,
13881                        const unsigned char * const end)
13882 {
13883   unsigned int tag;
13884   unsigned int len;
13885   unsigned int val;
13886
13887   tag = read_uleb128 (p, &len, end);
13888   p += len;
13889
13890   switch (tag)
13891     {
13892     case Tag_ARC_PCS_config:
13893       val = read_uleb128 (p, &len, end);
13894       p += len;
13895       printf ("  Tag_ARC_PCS_config: ");
13896       switch (val)
13897         {
13898         case 0:
13899           printf (_("Absent/Non standard\n"));
13900           break;
13901         case 1:
13902           printf (_("Bare metal/mwdt\n"));
13903           break;
13904         case 2:
13905           printf (_("Bare metal/newlib\n"));
13906           break;
13907         case 3:
13908           printf (_("Linux/uclibc\n"));
13909           break;
13910         case 4:
13911           printf (_("Linux/glibc\n"));
13912           break;
13913         default:
13914           printf (_("Unknown\n"));
13915           break;
13916         }
13917       break;
13918
13919     case Tag_ARC_CPU_base:
13920       val = read_uleb128 (p, &len, end);
13921       p += len;
13922       printf ("  Tag_ARC_CPU_base: ");
13923       switch (val)
13924         {
13925         default:
13926         case TAG_CPU_NONE:
13927           printf (_("Absent\n"));
13928           break;
13929         case TAG_CPU_ARC6xx:
13930           printf ("ARC6xx\n");
13931           break;
13932         case TAG_CPU_ARC7xx:
13933           printf ("ARC7xx\n");
13934           break;
13935         case TAG_CPU_ARCEM:
13936           printf ("ARCEM\n");
13937           break;
13938         case TAG_CPU_ARCHS:
13939           printf ("ARCHS\n");
13940           break;
13941         }
13942       break;
13943
13944     case Tag_ARC_CPU_variation:
13945       val = read_uleb128 (p, &len, end);
13946       p += len;
13947       printf ("  Tag_ARC_CPU_variation: ");
13948       switch (val)
13949         {
13950         default:
13951           if (val > 0 && val < 16)
13952               printf ("Core%d\n", val);
13953           else
13954               printf ("Unknown\n");
13955           break;
13956
13957         case 0:
13958           printf (_("Absent\n"));
13959           break;
13960         }
13961       break;
13962
13963     case Tag_ARC_CPU_name:
13964       printf ("  Tag_ARC_CPU_name: ");
13965       p = display_tag_value (-1, p, end);
13966       break;
13967
13968     case Tag_ARC_ABI_rf16:
13969       val = read_uleb128 (p, &len, end);
13970       p += len;
13971       printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
13972       break;
13973
13974     case Tag_ARC_ABI_osver:
13975       val = read_uleb128 (p, &len, end);
13976       p += len;
13977       printf ("  Tag_ARC_ABI_osver: v%d\n", val);
13978       break;
13979
13980     case Tag_ARC_ABI_pic:
13981     case Tag_ARC_ABI_sda:
13982       val = read_uleb128 (p, &len, end);
13983       p += len;
13984       printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
13985               : "  Tag_ARC_ABI_pic: ");
13986       switch (val)
13987         {
13988         case 0:
13989           printf (_("Absent\n"));
13990           break;
13991         case 1:
13992           printf ("MWDT\n");
13993           break;
13994         case 2:
13995           printf ("GNU\n");
13996           break;
13997         default:
13998           printf (_("Unknown\n"));
13999           break;
14000         }
14001       break;
14002
14003     case Tag_ARC_ABI_tls:
14004       val = read_uleb128 (p, &len, end);
14005       p += len;
14006       printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14007       break;
14008
14009     case Tag_ARC_ABI_enumsize:
14010       val = read_uleb128 (p, &len, end);
14011       p += len;
14012       printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14013               _("smallest"));
14014       break;
14015
14016     case Tag_ARC_ABI_exceptions:
14017       val = read_uleb128 (p, &len, end);
14018       p += len;
14019       printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14020               : _("default"));
14021       break;
14022
14023     case Tag_ARC_ABI_double_size:
14024       val = read_uleb128 (p, &len, end);
14025       p += len;
14026       printf ("  Tag_ARC_ABI_double_size: %d\n", val);
14027       break;
14028
14029     case Tag_ARC_ISA_config:
14030       printf ("  Tag_ARC_ISA_config: ");
14031       p = display_tag_value (-1, p, end);
14032       break;
14033
14034     case Tag_ARC_ISA_apex:
14035       printf ("  Tag_ARC_ISA_apex: ");
14036       p = display_tag_value (-1, p, end);
14037       break;
14038
14039     case Tag_ARC_ISA_mpy_option:
14040       val = read_uleb128 (p, &len, end);
14041       p += len;
14042       printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
14043       break;
14044
14045     default:
14046       return display_tag_value (tag & 1, p, end);
14047     }
14048
14049   return p;
14050 }
14051
14052 /* ARM EABI attributes section.  */
14053 typedef struct
14054 {
14055   unsigned int tag;
14056   const char * name;
14057   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
14058   unsigned int type;
14059   const char ** table;
14060 } arm_attr_public_tag;
14061
14062 static const char * arm_attr_tag_CPU_arch[] =
14063   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14064    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14065    "v8-M.mainline"};
14066 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14067 static const char * arm_attr_tag_THUMB_ISA_use[] =
14068   {"No", "Thumb-1", "Thumb-2", "Yes"};
14069 static const char * arm_attr_tag_FP_arch[] =
14070   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14071    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14072 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14073 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14074   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14075    "NEON for ARMv8.1"};
14076 static const char * arm_attr_tag_PCS_config[] =
14077   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14078    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14079 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14080   {"V6", "SB", "TLS", "Unused"};
14081 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14082   {"Absolute", "PC-relative", "SB-relative", "None"};
14083 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14084   {"Absolute", "PC-relative", "None"};
14085 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14086   {"None", "direct", "GOT-indirect"};
14087 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14088   {"None", "??? 1", "2", "??? 3", "4"};
14089 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14090 static const char * arm_attr_tag_ABI_FP_denormal[] =
14091   {"Unused", "Needed", "Sign only"};
14092 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14093 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14094 static const char * arm_attr_tag_ABI_FP_number_model[] =
14095   {"Unused", "Finite", "RTABI", "IEEE 754"};
14096 static const char * arm_attr_tag_ABI_enum_size[] =
14097   {"Unused", "small", "int", "forced to int"};
14098 static const char * arm_attr_tag_ABI_HardFP_use[] =
14099   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14100 static const char * arm_attr_tag_ABI_VFP_args[] =
14101   {"AAPCS", "VFP registers", "custom", "compatible"};
14102 static const char * arm_attr_tag_ABI_WMMX_args[] =
14103   {"AAPCS", "WMMX registers", "custom"};
14104 static const char * arm_attr_tag_ABI_optimization_goals[] =
14105   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14106     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14107 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14108   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14109     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14110 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14111 static const char * arm_attr_tag_FP_HP_extension[] =
14112   {"Not Allowed", "Allowed"};
14113 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14114   {"None", "IEEE 754", "Alternative Format"};
14115 static const char * arm_attr_tag_DSP_extension[] =
14116   {"Follow architecture", "Allowed"};
14117 static const char * arm_attr_tag_MPextension_use[] =
14118   {"Not Allowed", "Allowed"};
14119 static const char * arm_attr_tag_DIV_use[] =
14120   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14121     "Allowed in v7-A with integer division extension"};
14122 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14123 static const char * arm_attr_tag_Virtualization_use[] =
14124   {"Not Allowed", "TrustZone", "Virtualization Extensions",
14125     "TrustZone and Virtualization Extensions"};
14126 static const char * arm_attr_tag_MPextension_use_legacy[] =
14127   {"Not Allowed", "Allowed"};
14128
14129 #define LOOKUP(id, name) \
14130   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14131 static arm_attr_public_tag arm_attr_public_tags[] =
14132 {
14133   {4, "CPU_raw_name", 1, NULL},
14134   {5, "CPU_name", 1, NULL},
14135   LOOKUP(6, CPU_arch),
14136   {7, "CPU_arch_profile", 0, NULL},
14137   LOOKUP(8, ARM_ISA_use),
14138   LOOKUP(9, THUMB_ISA_use),
14139   LOOKUP(10, FP_arch),
14140   LOOKUP(11, WMMX_arch),
14141   LOOKUP(12, Advanced_SIMD_arch),
14142   LOOKUP(13, PCS_config),
14143   LOOKUP(14, ABI_PCS_R9_use),
14144   LOOKUP(15, ABI_PCS_RW_data),
14145   LOOKUP(16, ABI_PCS_RO_data),
14146   LOOKUP(17, ABI_PCS_GOT_use),
14147   LOOKUP(18, ABI_PCS_wchar_t),
14148   LOOKUP(19, ABI_FP_rounding),
14149   LOOKUP(20, ABI_FP_denormal),
14150   LOOKUP(21, ABI_FP_exceptions),
14151   LOOKUP(22, ABI_FP_user_exceptions),
14152   LOOKUP(23, ABI_FP_number_model),
14153   {24, "ABI_align_needed", 0, NULL},
14154   {25, "ABI_align_preserved", 0, NULL},
14155   LOOKUP(26, ABI_enum_size),
14156   LOOKUP(27, ABI_HardFP_use),
14157   LOOKUP(28, ABI_VFP_args),
14158   LOOKUP(29, ABI_WMMX_args),
14159   LOOKUP(30, ABI_optimization_goals),
14160   LOOKUP(31, ABI_FP_optimization_goals),
14161   {32, "compatibility", 0, NULL},
14162   LOOKUP(34, CPU_unaligned_access),
14163   LOOKUP(36, FP_HP_extension),
14164   LOOKUP(38, ABI_FP_16bit_format),
14165   LOOKUP(42, MPextension_use),
14166   LOOKUP(44, DIV_use),
14167   LOOKUP(46, DSP_extension),
14168   {64, "nodefaults", 0, NULL},
14169   {65, "also_compatible_with", 0, NULL},
14170   LOOKUP(66, T2EE_use),
14171   {67, "conformance", 1, NULL},
14172   LOOKUP(68, Virtualization_use),
14173   LOOKUP(70, MPextension_use_legacy)
14174 };
14175 #undef LOOKUP
14176
14177 static unsigned char *
14178 display_arm_attribute (unsigned char * p,
14179                        const unsigned char * const end)
14180 {
14181   unsigned int tag;
14182   unsigned int len;
14183   unsigned int val;
14184   arm_attr_public_tag * attr;
14185   unsigned i;
14186   unsigned int type;
14187
14188   tag = read_uleb128 (p, &len, end);
14189   p += len;
14190   attr = NULL;
14191   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14192     {
14193       if (arm_attr_public_tags[i].tag == tag)
14194         {
14195           attr = &arm_attr_public_tags[i];
14196           break;
14197         }
14198     }
14199
14200   if (attr)
14201     {
14202       printf ("  Tag_%s: ", attr->name);
14203       switch (attr->type)
14204         {
14205         case 0:
14206           switch (tag)
14207             {
14208             case 7: /* Tag_CPU_arch_profile.  */
14209               val = read_uleb128 (p, &len, end);
14210               p += len;
14211               switch (val)
14212                 {
14213                 case 0: printf (_("None\n")); break;
14214                 case 'A': printf (_("Application\n")); break;
14215                 case 'R': printf (_("Realtime\n")); break;
14216                 case 'M': printf (_("Microcontroller\n")); break;
14217                 case 'S': printf (_("Application or Realtime\n")); break;
14218                 default: printf ("??? (%d)\n", val); break;
14219                 }
14220               break;
14221
14222             case 24: /* Tag_align_needed.  */
14223               val = read_uleb128 (p, &len, end);
14224               p += len;
14225               switch (val)
14226                 {
14227                 case 0: printf (_("None\n")); break;
14228                 case 1: printf (_("8-byte\n")); break;
14229                 case 2: printf (_("4-byte\n")); break;
14230                 case 3: printf ("??? 3\n"); break;
14231                 default:
14232                   if (val <= 12)
14233                     printf (_("8-byte and up to %d-byte extended\n"),
14234                             1 << val);
14235                   else
14236                     printf ("??? (%d)\n", val);
14237                   break;
14238                 }
14239               break;
14240
14241             case 25: /* Tag_align_preserved.  */
14242               val = read_uleb128 (p, &len, end);
14243               p += len;
14244               switch (val)
14245                 {
14246                 case 0: printf (_("None\n")); break;
14247                 case 1: printf (_("8-byte, except leaf SP\n")); break;
14248                 case 2: printf (_("8-byte\n")); break;
14249                 case 3: printf ("??? 3\n"); break;
14250                 default:
14251                   if (val <= 12)
14252                     printf (_("8-byte and up to %d-byte extended\n"),
14253                             1 << val);
14254                   else
14255                     printf ("??? (%d)\n", val);
14256                   break;
14257                 }
14258               break;
14259
14260             case 32: /* Tag_compatibility.  */
14261               {
14262                 val = read_uleb128 (p, &len, end);
14263                 p += len;
14264                 printf (_("flag = %d, vendor = "), val);
14265                 if (p < end - 1)
14266                   {
14267                     size_t maxlen = (end - p) - 1;
14268
14269                     print_symbol ((int) maxlen, (const char *) p);
14270                     p += strnlen ((char *) p, maxlen) + 1;
14271                   }
14272                 else
14273                   {
14274                     printf (_("<corrupt>"));
14275                     p = (unsigned char *) end;
14276                   }
14277                 putchar ('\n');
14278               }
14279               break;
14280
14281             case 64: /* Tag_nodefaults.  */
14282               /* PR 17531: file: 001-505008-0.01.  */
14283               if (p < end)
14284                 p++;
14285               printf (_("True\n"));
14286               break;
14287
14288             case 65: /* Tag_also_compatible_with.  */
14289               val = read_uleb128 (p, &len, end);
14290               p += len;
14291               if (val == 6 /* Tag_CPU_arch.  */)
14292                 {
14293                   val = read_uleb128 (p, &len, end);
14294                   p += len;
14295                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14296                     printf ("??? (%d)\n", val);
14297                   else
14298                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14299                 }
14300               else
14301                 printf ("???\n");
14302               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
14303                 ;
14304               break;
14305
14306             default:
14307               printf (_("<unknown: %d>\n"), tag);
14308               break;
14309             }
14310           return p;
14311
14312         case 1:
14313           return display_tag_value (-1, p, end);
14314         case 2:
14315           return display_tag_value (0, p, end);
14316
14317         default:
14318           assert (attr->type & 0x80);
14319           val = read_uleb128 (p, &len, end);
14320           p += len;
14321           type = attr->type & 0x7f;
14322           if (val >= type)
14323             printf ("??? (%d)\n", val);
14324           else
14325             printf ("%s\n", attr->table[val]);
14326           return p;
14327         }
14328     }
14329
14330   return display_tag_value (tag, p, end);
14331 }
14332
14333 static unsigned char *
14334 display_gnu_attribute (unsigned char * p,
14335                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14336                        const unsigned char * const end)
14337 {
14338   int tag;
14339   unsigned int len;
14340   unsigned int val;
14341
14342   tag = read_uleb128 (p, &len, end);
14343   p += len;
14344
14345   /* Tag_compatibility is the only generic GNU attribute defined at
14346      present.  */
14347   if (tag == 32)
14348     {
14349       val = read_uleb128 (p, &len, end);
14350       p += len;
14351
14352       printf (_("flag = %d, vendor = "), val);
14353       if (p == end)
14354         {
14355           printf (_("<corrupt>\n"));
14356           warn (_("corrupt vendor attribute\n"));
14357         }
14358       else
14359         {
14360           if (p < end - 1)
14361             {
14362               size_t maxlen = (end - p) - 1;
14363
14364               print_symbol ((int) maxlen, (const char *) p);
14365               p += strnlen ((char *) p, maxlen) + 1;
14366             }
14367           else
14368             {
14369               printf (_("<corrupt>"));
14370               p = (unsigned char *) end;
14371             }
14372           putchar ('\n');
14373         }
14374       return p;
14375     }
14376
14377   if ((tag & 2) == 0 && display_proc_gnu_attribute)
14378     return display_proc_gnu_attribute (p, tag, end);
14379
14380   return display_tag_value (tag, p, end);
14381 }
14382
14383 static unsigned char *
14384 display_power_gnu_attribute (unsigned char * p,
14385                              unsigned int tag,
14386                              const unsigned char * const end)
14387 {
14388   unsigned int len;
14389   unsigned int val;
14390
14391   if (tag == Tag_GNU_Power_ABI_FP)
14392     {
14393       val = read_uleb128 (p, &len, end);
14394       p += len;
14395       printf ("  Tag_GNU_Power_ABI_FP: ");
14396       if (len == 0)
14397         {
14398           printf (_("<corrupt>\n"));
14399           return p;
14400         }
14401
14402       if (val > 15)
14403         printf ("(%#x), ", val);
14404
14405       switch (val & 3)
14406         {
14407         case 0:
14408           printf (_("unspecified hard/soft float, "));
14409           break;
14410         case 1:
14411           printf (_("hard float, "));
14412           break;
14413         case 2:
14414           printf (_("soft float, "));
14415           break;
14416         case 3:
14417           printf (_("single-precision hard float, "));
14418           break;
14419         }
14420
14421       switch (val & 0xC)
14422         {
14423         case 0:
14424           printf (_("unspecified long double\n"));
14425           break;
14426         case 4:
14427           printf (_("128-bit IBM long double\n"));
14428           break;
14429         case 8:
14430           printf (_("64-bit long double\n"));
14431           break;
14432         case 12:
14433           printf (_("128-bit IEEE long double\n"));
14434           break;
14435         }
14436       return p;
14437     }
14438
14439   if (tag == Tag_GNU_Power_ABI_Vector)
14440     {
14441       val = read_uleb128 (p, &len, end);
14442       p += len;
14443       printf ("  Tag_GNU_Power_ABI_Vector: ");
14444       if (len == 0)
14445         {
14446           printf (_("<corrupt>\n"));
14447           return p;
14448         }
14449
14450       if (val > 3)
14451         printf ("(%#x), ", val);
14452
14453       switch (val & 3)
14454         {
14455         case 0:
14456           printf (_("unspecified\n"));
14457           break;
14458         case 1:
14459           printf (_("generic\n"));
14460           break;
14461         case 2:
14462           printf ("AltiVec\n");
14463           break;
14464         case 3:
14465           printf ("SPE\n");
14466           break;
14467         }
14468       return p;
14469     }
14470
14471   if (tag == Tag_GNU_Power_ABI_Struct_Return)
14472     {
14473       val = read_uleb128 (p, &len, end);
14474       p += len;
14475       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
14476       if (len == 0)
14477         {
14478           printf (_("<corrupt>\n"));
14479           return p;
14480         }
14481
14482       if (val > 2)
14483         printf ("(%#x), ", val);
14484
14485       switch (val & 3)
14486         {
14487         case 0:
14488           printf (_("unspecified\n"));
14489           break;
14490         case 1:
14491           printf ("r3/r4\n");
14492           break;
14493         case 2:
14494           printf (_("memory\n"));
14495           break;
14496         case 3:
14497           printf ("???\n");
14498           break;
14499         }
14500       return p;
14501     }
14502
14503   return display_tag_value (tag & 1, p, end);
14504 }
14505
14506 static unsigned char *
14507 display_s390_gnu_attribute (unsigned char * p,
14508                             unsigned int tag,
14509                             const unsigned char * const end)
14510 {
14511   unsigned int len;
14512   int val;
14513
14514   if (tag == Tag_GNU_S390_ABI_Vector)
14515     {
14516       val = read_uleb128 (p, &len, end);
14517       p += len;
14518       printf ("  Tag_GNU_S390_ABI_Vector: ");
14519
14520       switch (val)
14521         {
14522         case 0:
14523           printf (_("any\n"));
14524           break;
14525         case 1:
14526           printf (_("software\n"));
14527           break;
14528         case 2:
14529           printf (_("hardware\n"));
14530           break;
14531         default:
14532           printf ("??? (%d)\n", val);
14533           break;
14534         }
14535       return p;
14536    }
14537
14538   return display_tag_value (tag & 1, p, end);
14539 }
14540
14541 static void
14542 display_sparc_hwcaps (unsigned int mask)
14543 {
14544   if (mask)
14545     {
14546       bfd_boolean first = TRUE;
14547
14548       if (mask & ELF_SPARC_HWCAP_MUL32)
14549         fputs ("mul32", stdout), first = FALSE;
14550       if (mask & ELF_SPARC_HWCAP_DIV32)
14551         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14552       if (mask & ELF_SPARC_HWCAP_FSMULD)
14553         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14554       if (mask & ELF_SPARC_HWCAP_V8PLUS)
14555         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14556       if (mask & ELF_SPARC_HWCAP_POPC)
14557         printf ("%spopc", first ? "" : "|"), first = FALSE;
14558       if (mask & ELF_SPARC_HWCAP_VIS)
14559         printf ("%svis", first ? "" : "|"), first = FALSE;
14560       if (mask & ELF_SPARC_HWCAP_VIS2)
14561         printf ("%svis2", first ? "" : "|"), first = FALSE;
14562       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14563         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14564       if (mask & ELF_SPARC_HWCAP_FMAF)
14565         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14566       if (mask & ELF_SPARC_HWCAP_VIS3)
14567         printf ("%svis3", first ? "" : "|"), first = FALSE;
14568       if (mask & ELF_SPARC_HWCAP_HPC)
14569         printf ("%shpc", first ? "" : "|"), first = FALSE;
14570       if (mask & ELF_SPARC_HWCAP_RANDOM)
14571         printf ("%srandom", first ? "" : "|"), first = FALSE;
14572       if (mask & ELF_SPARC_HWCAP_TRANS)
14573         printf ("%strans", first ? "" : "|"), first = FALSE;
14574       if (mask & ELF_SPARC_HWCAP_FJFMAU)
14575         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14576       if (mask & ELF_SPARC_HWCAP_IMA)
14577         printf ("%sima", first ? "" : "|"), first = FALSE;
14578       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14579         printf ("%scspare", first ? "" : "|"), first = FALSE;
14580     }
14581   else
14582     fputc ('0', stdout);
14583   fputc ('\n', stdout);
14584 }
14585
14586 static void
14587 display_sparc_hwcaps2 (unsigned int mask)
14588 {
14589   if (mask)
14590     {
14591       bfd_boolean first = TRUE;
14592
14593       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14594         fputs ("fjathplus", stdout), first = FALSE;
14595       if (mask & ELF_SPARC_HWCAP2_VIS3B)
14596         printf ("%svis3b", first ? "" : "|"), first = FALSE;
14597       if (mask & ELF_SPARC_HWCAP2_ADP)
14598         printf ("%sadp", first ? "" : "|"), first = FALSE;
14599       if (mask & ELF_SPARC_HWCAP2_SPARC5)
14600         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14601       if (mask & ELF_SPARC_HWCAP2_MWAIT)
14602         printf ("%smwait", first ? "" : "|"), first = FALSE;
14603       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14604         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14605       if (mask & ELF_SPARC_HWCAP2_XMONT)
14606         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14607       if (mask & ELF_SPARC_HWCAP2_NSEC)
14608         printf ("%snsec", first ? "" : "|"), first = FALSE;
14609       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14610         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14611       if (mask & ELF_SPARC_HWCAP2_FJDES)
14612         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14613       if (mask & ELF_SPARC_HWCAP2_FJAES)
14614         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14615     }
14616   else
14617     fputc ('0', stdout);
14618   fputc ('\n', stdout);
14619 }
14620
14621 static unsigned char *
14622 display_sparc_gnu_attribute (unsigned char * p,
14623                              unsigned int tag,
14624                              const unsigned char * const end)
14625 {
14626   unsigned int len;
14627   int val;
14628
14629   if (tag == Tag_GNU_Sparc_HWCAPS)
14630     {
14631       val = read_uleb128 (p, &len, end);
14632       p += len;
14633       printf ("  Tag_GNU_Sparc_HWCAPS: ");
14634       display_sparc_hwcaps (val);
14635       return p;
14636     }
14637   if (tag == Tag_GNU_Sparc_HWCAPS2)
14638     {
14639       val = read_uleb128 (p, &len, end);
14640       p += len;
14641       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
14642       display_sparc_hwcaps2 (val);
14643       return p;
14644     }
14645
14646   return display_tag_value (tag, p, end);
14647 }
14648
14649 static void
14650 print_mips_fp_abi_value (unsigned int val)
14651 {
14652   switch (val)
14653     {
14654     case Val_GNU_MIPS_ABI_FP_ANY:
14655       printf (_("Hard or soft float\n"));
14656       break;
14657     case Val_GNU_MIPS_ABI_FP_DOUBLE:
14658       printf (_("Hard float (double precision)\n"));
14659       break;
14660     case Val_GNU_MIPS_ABI_FP_SINGLE:
14661       printf (_("Hard float (single precision)\n"));
14662       break;
14663     case Val_GNU_MIPS_ABI_FP_SOFT:
14664       printf (_("Soft float\n"));
14665       break;
14666     case Val_GNU_MIPS_ABI_FP_OLD_64:
14667       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14668       break;
14669     case Val_GNU_MIPS_ABI_FP_XX:
14670       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14671       break;
14672     case Val_GNU_MIPS_ABI_FP_64:
14673       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14674       break;
14675     case Val_GNU_MIPS_ABI_FP_64A:
14676       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14677       break;
14678     case Val_GNU_MIPS_ABI_FP_NAN2008:
14679       printf (_("NaN 2008 compatibility\n"));
14680       break;
14681     default:
14682       printf ("??? (%d)\n", val);
14683       break;
14684     }
14685 }
14686
14687 static unsigned char *
14688 display_mips_gnu_attribute (unsigned char * p,
14689                             unsigned int tag,
14690                             const unsigned char * const end)
14691 {
14692   if (tag == Tag_GNU_MIPS_ABI_FP)
14693     {
14694       unsigned int len;
14695       unsigned int val;
14696
14697       val = read_uleb128 (p, &len, end);
14698       p += len;
14699       printf ("  Tag_GNU_MIPS_ABI_FP: ");
14700
14701       print_mips_fp_abi_value (val);
14702
14703       return p;
14704    }
14705
14706   if (tag == Tag_GNU_MIPS_ABI_MSA)
14707     {
14708       unsigned int len;
14709       unsigned int val;
14710
14711       val = read_uleb128 (p, &len, end);
14712       p += len;
14713       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
14714
14715       switch (val)
14716         {
14717         case Val_GNU_MIPS_ABI_MSA_ANY:
14718           printf (_("Any MSA or not\n"));
14719           break;
14720         case Val_GNU_MIPS_ABI_MSA_128:
14721           printf (_("128-bit MSA\n"));
14722           break;
14723         default:
14724           printf ("??? (%d)\n", val);
14725           break;
14726         }
14727       return p;
14728     }
14729
14730   return display_tag_value (tag & 1, p, end);
14731 }
14732
14733 static unsigned char *
14734 display_tic6x_attribute (unsigned char * p,
14735                          const unsigned char * const end)
14736 {
14737   unsigned int tag;
14738   unsigned int len;
14739   int val;
14740
14741   tag = read_uleb128 (p, &len, end);
14742   p += len;
14743
14744   switch (tag)
14745     {
14746     case Tag_ISA:
14747       val = read_uleb128 (p, &len, end);
14748       p += len;
14749       printf ("  Tag_ISA: ");
14750
14751       switch (val)
14752         {
14753         case C6XABI_Tag_ISA_none:
14754           printf (_("None\n"));
14755           break;
14756         case C6XABI_Tag_ISA_C62X:
14757           printf ("C62x\n");
14758           break;
14759         case C6XABI_Tag_ISA_C67X:
14760           printf ("C67x\n");
14761           break;
14762         case C6XABI_Tag_ISA_C67XP:
14763           printf ("C67x+\n");
14764           break;
14765         case C6XABI_Tag_ISA_C64X:
14766           printf ("C64x\n");
14767           break;
14768         case C6XABI_Tag_ISA_C64XP:
14769           printf ("C64x+\n");
14770           break;
14771         case C6XABI_Tag_ISA_C674X:
14772           printf ("C674x\n");
14773           break;
14774         default:
14775           printf ("??? (%d)\n", val);
14776           break;
14777         }
14778       return p;
14779
14780     case Tag_ABI_wchar_t:
14781       val = read_uleb128 (p, &len, end);
14782       p += len;
14783       printf ("  Tag_ABI_wchar_t: ");
14784       switch (val)
14785         {
14786         case 0:
14787           printf (_("Not used\n"));
14788           break;
14789         case 1:
14790           printf (_("2 bytes\n"));
14791           break;
14792         case 2:
14793           printf (_("4 bytes\n"));
14794           break;
14795         default:
14796           printf ("??? (%d)\n", val);
14797           break;
14798         }
14799       return p;
14800
14801     case Tag_ABI_stack_align_needed:
14802       val = read_uleb128 (p, &len, end);
14803       p += len;
14804       printf ("  Tag_ABI_stack_align_needed: ");
14805       switch (val)
14806         {
14807         case 0:
14808           printf (_("8-byte\n"));
14809           break;
14810         case 1:
14811           printf (_("16-byte\n"));
14812           break;
14813         default:
14814           printf ("??? (%d)\n", val);
14815           break;
14816         }
14817       return p;
14818
14819     case Tag_ABI_stack_align_preserved:
14820       val = read_uleb128 (p, &len, end);
14821       p += len;
14822       printf ("  Tag_ABI_stack_align_preserved: ");
14823       switch (val)
14824         {
14825         case 0:
14826           printf (_("8-byte\n"));
14827           break;
14828         case 1:
14829           printf (_("16-byte\n"));
14830           break;
14831         default:
14832           printf ("??? (%d)\n", val);
14833           break;
14834         }
14835       return p;
14836
14837     case Tag_ABI_DSBT:
14838       val = read_uleb128 (p, &len, end);
14839       p += len;
14840       printf ("  Tag_ABI_DSBT: ");
14841       switch (val)
14842         {
14843         case 0:
14844           printf (_("DSBT addressing not used\n"));
14845           break;
14846         case 1:
14847           printf (_("DSBT addressing used\n"));
14848           break;
14849         default:
14850           printf ("??? (%d)\n", val);
14851           break;
14852         }
14853       return p;
14854
14855     case Tag_ABI_PID:
14856       val = read_uleb128 (p, &len, end);
14857       p += len;
14858       printf ("  Tag_ABI_PID: ");
14859       switch (val)
14860         {
14861         case 0:
14862           printf (_("Data addressing position-dependent\n"));
14863           break;
14864         case 1:
14865           printf (_("Data addressing position-independent, GOT near DP\n"));
14866           break;
14867         case 2:
14868           printf (_("Data addressing position-independent, GOT far from DP\n"));
14869           break;
14870         default:
14871           printf ("??? (%d)\n", val);
14872           break;
14873         }
14874       return p;
14875
14876     case Tag_ABI_PIC:
14877       val = read_uleb128 (p, &len, end);
14878       p += len;
14879       printf ("  Tag_ABI_PIC: ");
14880       switch (val)
14881         {
14882         case 0:
14883           printf (_("Code addressing position-dependent\n"));
14884           break;
14885         case 1:
14886           printf (_("Code addressing position-independent\n"));
14887           break;
14888         default:
14889           printf ("??? (%d)\n", val);
14890           break;
14891         }
14892       return p;
14893
14894     case Tag_ABI_array_object_alignment:
14895       val = read_uleb128 (p, &len, end);
14896       p += len;
14897       printf ("  Tag_ABI_array_object_alignment: ");
14898       switch (val)
14899         {
14900         case 0:
14901           printf (_("8-byte\n"));
14902           break;
14903         case 1:
14904           printf (_("4-byte\n"));
14905           break;
14906         case 2:
14907           printf (_("16-byte\n"));
14908           break;
14909         default:
14910           printf ("??? (%d)\n", val);
14911           break;
14912         }
14913       return p;
14914
14915     case Tag_ABI_array_object_align_expected:
14916       val = read_uleb128 (p, &len, end);
14917       p += len;
14918       printf ("  Tag_ABI_array_object_align_expected: ");
14919       switch (val)
14920         {
14921         case 0:
14922           printf (_("8-byte\n"));
14923           break;
14924         case 1:
14925           printf (_("4-byte\n"));
14926           break;
14927         case 2:
14928           printf (_("16-byte\n"));
14929           break;
14930         default:
14931           printf ("??? (%d)\n", val);
14932           break;
14933         }
14934       return p;
14935
14936     case Tag_ABI_compatibility:
14937       {
14938         val = read_uleb128 (p, &len, end);
14939         p += len;
14940         printf ("  Tag_ABI_compatibility: ");
14941         printf (_("flag = %d, vendor = "), val);
14942         if (p < end - 1)
14943           {
14944             size_t maxlen = (end - p) - 1;
14945
14946             print_symbol ((int) maxlen, (const char *) p);
14947             p += strnlen ((char *) p, maxlen) + 1;
14948           }
14949         else
14950           {
14951             printf (_("<corrupt>"));
14952             p = (unsigned char *) end;
14953           }
14954         putchar ('\n');
14955         return p;
14956       }
14957
14958     case Tag_ABI_conformance:
14959       {
14960         printf ("  Tag_ABI_conformance: \"");
14961         if (p < end - 1)
14962           {
14963             size_t maxlen = (end - p) - 1;
14964
14965             print_symbol ((int) maxlen, (const char *) p);
14966             p += strnlen ((char *) p, maxlen) + 1;
14967           }
14968         else
14969           {
14970             printf (_("<corrupt>"));
14971             p = (unsigned char *) end;
14972           }
14973         printf ("\"\n");
14974         return p;
14975       }
14976     }
14977
14978   return display_tag_value (tag, p, end);
14979 }
14980
14981 static void
14982 display_raw_attribute (unsigned char * p, unsigned char const * const end)
14983 {
14984   unsigned long addr = 0;
14985   size_t bytes = end - p;
14986
14987   assert (end > p);
14988   while (bytes)
14989     {
14990       int j;
14991       int k;
14992       int lbytes = (bytes > 16 ? 16 : bytes);
14993
14994       printf ("  0x%8.8lx ", addr);
14995
14996       for (j = 0; j < 16; j++)
14997         {
14998           if (j < lbytes)
14999             printf ("%2.2x", p[j]);
15000           else
15001             printf ("  ");
15002
15003           if ((j & 3) == 3)
15004             printf (" ");
15005         }
15006
15007       for (j = 0; j < lbytes; j++)
15008         {
15009           k = p[j];
15010           if (k >= ' ' && k < 0x7f)
15011             printf ("%c", k);
15012           else
15013             printf (".");
15014         }
15015
15016       putchar ('\n');
15017
15018       p  += lbytes;
15019       bytes -= lbytes;
15020       addr += lbytes;
15021     }
15022
15023   putchar ('\n');
15024 }
15025
15026 static unsigned char *
15027 display_msp430x_attribute (unsigned char * p,
15028                            const unsigned char * const end)
15029 {
15030   unsigned int len;
15031   unsigned int val;
15032   unsigned int tag;
15033
15034   tag = read_uleb128 (p, & len, end);
15035   p += len;
15036
15037   switch (tag)
15038     {
15039     case OFBA_MSPABI_Tag_ISA:
15040       val = read_uleb128 (p, &len, end);
15041       p += len;
15042       printf ("  Tag_ISA: ");
15043       switch (val)
15044         {
15045         case 0: printf (_("None\n")); break;
15046         case 1: printf (_("MSP430\n")); break;
15047         case 2: printf (_("MSP430X\n")); break;
15048         default: printf ("??? (%d)\n", val); break;
15049         }
15050       break;
15051
15052     case OFBA_MSPABI_Tag_Code_Model:
15053       val = read_uleb128 (p, &len, end);
15054       p += len;
15055       printf ("  Tag_Code_Model: ");
15056       switch (val)
15057         {
15058         case 0: printf (_("None\n")); break;
15059         case 1: printf (_("Small\n")); break;
15060         case 2: printf (_("Large\n")); break;
15061         default: printf ("??? (%d)\n", val); break;
15062         }
15063       break;
15064
15065     case OFBA_MSPABI_Tag_Data_Model:
15066       val = read_uleb128 (p, &len, end);
15067       p += len;
15068       printf ("  Tag_Data_Model: ");
15069       switch (val)
15070         {
15071         case 0: printf (_("None\n")); break;
15072         case 1: printf (_("Small\n")); break;
15073         case 2: printf (_("Large\n")); break;
15074         case 3: printf (_("Restricted Large\n")); break;
15075         default: printf ("??? (%d)\n", val); break;
15076         }
15077       break;
15078
15079     default:
15080       printf (_("  <unknown tag %d>: "), tag);
15081
15082       if (tag & 1)
15083         {
15084           putchar ('"');
15085           if (p < end - 1)
15086             {
15087               size_t maxlen = (end - p) - 1;
15088
15089               print_symbol ((int) maxlen, (const char *) p);
15090               p += strnlen ((char *) p, maxlen) + 1;
15091             }
15092           else
15093             {
15094               printf (_("<corrupt>"));
15095               p = (unsigned char *) end;
15096             }
15097           printf ("\"\n");
15098         }
15099       else
15100         {
15101           val = read_uleb128 (p, &len, end);
15102           p += len;
15103           printf ("%d (0x%x)\n", val, val);
15104         }
15105       break;
15106    }
15107
15108   assert (p <= end);
15109   return p;
15110 }
15111
15112 static bfd_boolean
15113 process_attributes (Filedata * filedata,
15114                     const char * public_name,
15115                     unsigned int proc_type,
15116                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15117                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15118 {
15119   Elf_Internal_Shdr * sect;
15120   unsigned i;
15121   bfd_boolean res = TRUE;
15122
15123   /* Find the section header so that we get the size.  */
15124   for (i = 0, sect = filedata->section_headers;
15125        i < filedata->file_header.e_shnum;
15126        i++, sect++)
15127     {
15128       unsigned char * contents;
15129       unsigned char * p;
15130
15131       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15132         continue;
15133
15134       contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15135                                              sect->sh_size, _("attributes"));
15136       if (contents == NULL)
15137         {
15138           res = FALSE;
15139           continue;
15140         }
15141
15142       p = contents;
15143       /* The first character is the version of the attributes.
15144          Currently only version 1, (aka 'A') is recognised here.  */
15145       if (*p != 'A')
15146         {
15147           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15148           res = FALSE;
15149         }
15150       else
15151         {
15152           bfd_vma section_len;
15153
15154           section_len = sect->sh_size - 1;
15155           p++;
15156
15157           while (section_len > 0)
15158             {
15159               bfd_vma attr_len;
15160               unsigned int namelen;
15161               bfd_boolean public_section;
15162               bfd_boolean gnu_section;
15163
15164               if (section_len <= 4)
15165                 {
15166                   error (_("Tag section ends prematurely\n"));
15167                   res = FALSE;
15168                   break;
15169                 }
15170               attr_len = byte_get (p, 4);
15171               p += 4;
15172
15173               if (attr_len > section_len)
15174                 {
15175                   error (_("Bad attribute length (%u > %u)\n"),
15176                           (unsigned) attr_len, (unsigned) section_len);
15177                   attr_len = section_len;
15178                   res = FALSE;
15179                 }
15180               /* PR 17531: file: 001-101425-0.004  */
15181               else if (attr_len < 5)
15182                 {
15183                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
15184                   res = FALSE;
15185                   break;
15186                 }
15187
15188               section_len -= attr_len;
15189               attr_len -= 4;
15190
15191               namelen = strnlen ((char *) p, attr_len) + 1;
15192               if (namelen == 0 || namelen >= attr_len)
15193                 {
15194                   error (_("Corrupt attribute section name\n"));
15195                   res = FALSE;
15196                   break;
15197                 }
15198
15199               printf (_("Attribute Section: "));
15200               print_symbol (INT_MAX, (const char *) p);
15201               putchar ('\n');
15202
15203               if (public_name && streq ((char *) p, public_name))
15204                 public_section = TRUE;
15205               else
15206                 public_section = FALSE;
15207
15208               if (streq ((char *) p, "gnu"))
15209                 gnu_section = TRUE;
15210               else
15211                 gnu_section = FALSE;
15212
15213               p += namelen;
15214               attr_len -= namelen;
15215
15216               while (attr_len > 0 && p < contents + sect->sh_size)
15217                 {
15218                   int tag;
15219                   int val;
15220                   bfd_vma size;
15221                   unsigned char * end;
15222
15223                   /* PR binutils/17531: Safe handling of corrupt files.  */
15224                   if (attr_len < 6)
15225                     {
15226                       error (_("Unused bytes at end of section\n"));
15227                       res = FALSE;
15228                       section_len = 0;
15229                       break;
15230                     }
15231
15232                   tag = *(p++);
15233                   size = byte_get (p, 4);
15234                   if (size > attr_len)
15235                     {
15236                       error (_("Bad subsection length (%u > %u)\n"),
15237                               (unsigned) size, (unsigned) attr_len);
15238                       res = FALSE;
15239                       size = attr_len;
15240                     }
15241                   /* PR binutils/17531: Safe handling of corrupt files.  */
15242                   if (size < 6)
15243                     {
15244                       error (_("Bad subsection length (%u < 6)\n"),
15245                               (unsigned) size);
15246                       res = FALSE;
15247                       section_len = 0;
15248                       break;
15249                     }
15250
15251                   attr_len -= size;
15252                   end = p + size - 1;
15253                   assert (end <= contents + sect->sh_size);
15254                   p += 4;
15255
15256                   switch (tag)
15257                     {
15258                     case 1:
15259                       printf (_("File Attributes\n"));
15260                       break;
15261                     case 2:
15262                       printf (_("Section Attributes:"));
15263                       goto do_numlist;
15264                     case 3:
15265                       printf (_("Symbol Attributes:"));
15266                       /* Fall through.  */
15267                     do_numlist:
15268                       for (;;)
15269                         {
15270                           unsigned int j;
15271
15272                           val = read_uleb128 (p, &j, end);
15273                           p += j;
15274                           if (val == 0)
15275                             break;
15276                           printf (" %d", val);
15277                         }
15278                       printf ("\n");
15279                       break;
15280                     default:
15281                       printf (_("Unknown tag: %d\n"), tag);
15282                       public_section = FALSE;
15283                       break;
15284                     }
15285
15286                   if (public_section && display_pub_attribute != NULL)
15287                     {
15288                       while (p < end)
15289                         p = display_pub_attribute (p, end);
15290                       assert (p == end);
15291                     }
15292                   else if (gnu_section && display_proc_gnu_attribute != NULL)
15293                     {
15294                       while (p < end)
15295                         p = display_gnu_attribute (p,
15296                                                    display_proc_gnu_attribute,
15297                                                    end);
15298                       assert (p == end);
15299                     }
15300                   else if (p < end)
15301                     {
15302                       printf (_("  Unknown attribute:\n"));
15303                       display_raw_attribute (p, end);
15304                       p = end;
15305                     }
15306                   else
15307                     attr_len = 0;
15308                 }
15309             }
15310         }
15311
15312       free (contents);
15313     }
15314
15315   return res;
15316 }
15317
15318 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15319    Print the Address, Access and Initial fields of an entry at VMA ADDR
15320    and return the VMA of the next entry, or -1 if there was a problem.
15321    Does not read from DATA_END or beyond.  */
15322
15323 static bfd_vma
15324 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15325                       unsigned char * data_end)
15326 {
15327   printf ("  ");
15328   print_vma (addr, LONG_HEX);
15329   printf (" ");
15330   if (addr < pltgot + 0xfff0)
15331     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15332   else
15333     printf ("%10s", "");
15334   printf (" ");
15335   if (data == NULL)
15336     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15337   else
15338     {
15339       bfd_vma entry;
15340       unsigned char * from = data + addr - pltgot;
15341
15342       if (from + (is_32bit_elf ? 4 : 8) > data_end)
15343         {
15344           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15345           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15346           return (bfd_vma) -1;
15347         }
15348       else
15349         {
15350           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15351           print_vma (entry, LONG_HEX);
15352         }
15353     }
15354   return addr + (is_32bit_elf ? 4 : 8);
15355 }
15356
15357 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15358    PLTGOT.  Print the Address and Initial fields of an entry at VMA
15359    ADDR and return the VMA of the next entry.  */
15360
15361 static bfd_vma
15362 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15363 {
15364   printf ("  ");
15365   print_vma (addr, LONG_HEX);
15366   printf (" ");
15367   if (data == NULL)
15368     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15369   else
15370     {
15371       bfd_vma entry;
15372
15373       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15374       print_vma (entry, LONG_HEX);
15375     }
15376   return addr + (is_32bit_elf ? 4 : 8);
15377 }
15378
15379 static void
15380 print_mips_ases (unsigned int mask)
15381 {
15382   if (mask & AFL_ASE_DSP)
15383     fputs ("\n\tDSP ASE", stdout);
15384   if (mask & AFL_ASE_DSPR2)
15385     fputs ("\n\tDSP R2 ASE", stdout);
15386   if (mask & AFL_ASE_DSPR3)
15387     fputs ("\n\tDSP R3 ASE", stdout);
15388   if (mask & AFL_ASE_EVA)
15389     fputs ("\n\tEnhanced VA Scheme", stdout);
15390   if (mask & AFL_ASE_MCU)
15391     fputs ("\n\tMCU (MicroController) ASE", stdout);
15392   if (mask & AFL_ASE_MDMX)
15393     fputs ("\n\tMDMX ASE", stdout);
15394   if (mask & AFL_ASE_MIPS3D)
15395     fputs ("\n\tMIPS-3D ASE", stdout);
15396   if (mask & AFL_ASE_MT)
15397     fputs ("\n\tMT ASE", stdout);
15398   if (mask & AFL_ASE_SMARTMIPS)
15399     fputs ("\n\tSmartMIPS ASE", stdout);
15400   if (mask & AFL_ASE_VIRT)
15401     fputs ("\n\tVZ ASE", stdout);
15402   if (mask & AFL_ASE_MSA)
15403     fputs ("\n\tMSA ASE", stdout);
15404   if (mask & AFL_ASE_MIPS16)
15405     fputs ("\n\tMIPS16 ASE", stdout);
15406   if (mask & AFL_ASE_MICROMIPS)
15407     fputs ("\n\tMICROMIPS ASE", stdout);
15408   if (mask & AFL_ASE_XPA)
15409     fputs ("\n\tXPA ASE", stdout);
15410   if (mask & AFL_ASE_MIPS16E2)
15411     fputs ("\n\tMIPS16e2 ASE", stdout);
15412   if (mask == 0)
15413     fprintf (stdout, "\n\t%s", _("None"));
15414   else if ((mask & ~AFL_ASE_MASK) != 0)
15415     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15416 }
15417
15418 static void
15419 print_mips_isa_ext (unsigned int isa_ext)
15420 {
15421   switch (isa_ext)
15422     {
15423     case 0:
15424       fputs (_("None"), stdout);
15425       break;
15426     case AFL_EXT_XLR:
15427       fputs ("RMI XLR", stdout);
15428       break;
15429     case AFL_EXT_OCTEON3:
15430       fputs ("Cavium Networks Octeon3", stdout);
15431       break;
15432     case AFL_EXT_OCTEON2:
15433       fputs ("Cavium Networks Octeon2", stdout);
15434       break;
15435     case AFL_EXT_OCTEONP:
15436       fputs ("Cavium Networks OcteonP", stdout);
15437       break;
15438     case AFL_EXT_LOONGSON_3A:
15439       fputs ("Loongson 3A", stdout);
15440       break;
15441     case AFL_EXT_OCTEON:
15442       fputs ("Cavium Networks Octeon", stdout);
15443       break;
15444     case AFL_EXT_5900:
15445       fputs ("Toshiba R5900", stdout);
15446       break;
15447     case AFL_EXT_4650:
15448       fputs ("MIPS R4650", stdout);
15449       break;
15450     case AFL_EXT_4010:
15451       fputs ("LSI R4010", stdout);
15452       break;
15453     case AFL_EXT_4100:
15454       fputs ("NEC VR4100", stdout);
15455       break;
15456     case AFL_EXT_3900:
15457       fputs ("Toshiba R3900", stdout);
15458       break;
15459     case AFL_EXT_10000:
15460       fputs ("MIPS R10000", stdout);
15461       break;
15462     case AFL_EXT_SB1:
15463       fputs ("Broadcom SB-1", stdout);
15464       break;
15465     case AFL_EXT_4111:
15466       fputs ("NEC VR4111/VR4181", stdout);
15467       break;
15468     case AFL_EXT_4120:
15469       fputs ("NEC VR4120", stdout);
15470       break;
15471     case AFL_EXT_5400:
15472       fputs ("NEC VR5400", stdout);
15473       break;
15474     case AFL_EXT_5500:
15475       fputs ("NEC VR5500", stdout);
15476       break;
15477     case AFL_EXT_LOONGSON_2E:
15478       fputs ("ST Microelectronics Loongson 2E", stdout);
15479       break;
15480     case AFL_EXT_LOONGSON_2F:
15481       fputs ("ST Microelectronics Loongson 2F", stdout);
15482       break;
15483     case AFL_EXT_INTERAPTIV_MR2:
15484       fputs ("Imagination interAptiv MR2", stdout);
15485       break;
15486     default:
15487       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15488     }
15489 }
15490
15491 static signed int
15492 get_mips_reg_size (int reg_size)
15493 {
15494   return (reg_size == AFL_REG_NONE) ? 0
15495          : (reg_size == AFL_REG_32) ? 32
15496          : (reg_size == AFL_REG_64) ? 64
15497          : (reg_size == AFL_REG_128) ? 128
15498          : -1;
15499 }
15500
15501 static bfd_boolean
15502 process_mips_specific (Filedata * filedata)
15503 {
15504   Elf_Internal_Dyn * entry;
15505   Elf_Internal_Shdr *sect = NULL;
15506   size_t liblist_offset = 0;
15507   size_t liblistno = 0;
15508   size_t conflictsno = 0;
15509   size_t options_offset = 0;
15510   size_t conflicts_offset = 0;
15511   size_t pltrelsz = 0;
15512   size_t pltrel = 0;
15513   bfd_vma pltgot = 0;
15514   bfd_vma mips_pltgot = 0;
15515   bfd_vma jmprel = 0;
15516   bfd_vma local_gotno = 0;
15517   bfd_vma gotsym = 0;
15518   bfd_vma symtabno = 0;
15519   bfd_boolean res = TRUE;
15520
15521   if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
15522                             display_mips_gnu_attribute))
15523     res = FALSE;
15524
15525   sect = find_section (filedata, ".MIPS.abiflags");
15526
15527   if (sect != NULL)
15528     {
15529       Elf_External_ABIFlags_v0 *abiflags_ext;
15530       Elf_Internal_ABIFlags_v0 abiflags_in;
15531
15532       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15533         {
15534           error (_("Corrupt MIPS ABI Flags section.\n"));
15535           res = FALSE;
15536         }
15537       else
15538         {
15539           abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
15540                                    sect->sh_size, _("MIPS ABI Flags section"));
15541           if (abiflags_ext)
15542             {
15543               abiflags_in.version = BYTE_GET (abiflags_ext->version);
15544               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15545               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15546               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15547               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15548               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15549               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15550               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15551               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15552               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15553               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15554
15555               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15556               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15557               if (abiflags_in.isa_rev > 1)
15558                 printf ("r%d", abiflags_in.isa_rev);
15559               printf ("\nGPR size: %d",
15560                       get_mips_reg_size (abiflags_in.gpr_size));
15561               printf ("\nCPR1 size: %d",
15562                       get_mips_reg_size (abiflags_in.cpr1_size));
15563               printf ("\nCPR2 size: %d",
15564                       get_mips_reg_size (abiflags_in.cpr2_size));
15565               fputs ("\nFP ABI: ", stdout);
15566               print_mips_fp_abi_value (abiflags_in.fp_abi);
15567               fputs ("ISA Extension: ", stdout);
15568               print_mips_isa_ext (abiflags_in.isa_ext);
15569               fputs ("\nASEs:", stdout);
15570               print_mips_ases (abiflags_in.ases);
15571               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15572               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15573               fputc ('\n', stdout);
15574               free (abiflags_ext);
15575             }
15576         }
15577     }
15578
15579   /* We have a lot of special sections.  Thanks SGI!  */
15580   if (dynamic_section == NULL)
15581     {
15582       /* No dynamic information available.  See if there is static GOT.  */
15583       sect = find_section (filedata, ".got");
15584       if (sect != NULL)
15585         {
15586           unsigned char *data_end;
15587           unsigned char *data;
15588           bfd_vma ent, end;
15589           int addr_size;
15590
15591           pltgot = sect->sh_addr;
15592
15593           ent = pltgot;
15594           addr_size = (is_32bit_elf ? 4 : 8);
15595           end = pltgot + sect->sh_size;
15596
15597           data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
15598                                              end - pltgot, 1,
15599                                              _("Global Offset Table data"));
15600           /* PR 12855: Null data is handled gracefully throughout.  */
15601           data_end = data + (end - pltgot);
15602
15603           printf (_("\nStatic GOT:\n"));
15604           printf (_(" Canonical gp value: "));
15605           print_vma (ent + 0x7ff0, LONG_HEX);
15606           printf ("\n\n");
15607
15608           /* In a dynamic binary GOT[0] is reserved for the dynamic
15609              loader to store the lazy resolver pointer, however in
15610              a static binary it may well have been omitted and GOT
15611              reduced to a table of addresses.
15612              PR 21344: Check for the entry being fully available
15613              before fetching it.  */
15614           if (data
15615               && data + ent - pltgot + addr_size <= data_end
15616               && byte_get (data + ent - pltgot, addr_size) == 0)
15617             {
15618               printf (_(" Reserved entries:\n"));
15619               printf (_("  %*s %10s %*s\n"),
15620                       addr_size * 2, _("Address"), _("Access"),
15621                       addr_size * 2, _("Value"));
15622               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15623               printf ("\n");
15624               if (ent == (bfd_vma) -1)
15625                 goto sgot_print_fail;
15626
15627               /* Check for the MSB of GOT[1] being set, identifying a
15628                  GNU object.  This entry will be used by some runtime
15629                  loaders, to store the module pointer.  Otherwise this
15630                  is an ordinary local entry.
15631                  PR 21344: Check for the entry being fully available
15632                  before fetching it.  */
15633               if (data
15634                   && data + ent - pltgot + addr_size <= data_end
15635                   && (byte_get (data + ent - pltgot, addr_size)
15636                       >> (addr_size * 8 - 1)) != 0)
15637                 {
15638                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15639                   printf ("\n");
15640                   if (ent == (bfd_vma) -1)
15641                     goto sgot_print_fail;
15642                 }
15643               printf ("\n");
15644             }
15645
15646           if (data != NULL && ent < end)
15647             {
15648               printf (_(" Local entries:\n"));
15649               printf ("  %*s %10s %*s\n",
15650                       addr_size * 2, _("Address"), _("Access"),
15651                       addr_size * 2, _("Value"));
15652               while (ent < end)
15653                 {
15654                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15655                   printf ("\n");
15656                   if (ent == (bfd_vma) -1)
15657                     goto sgot_print_fail;
15658                 }
15659               printf ("\n");
15660             }
15661
15662         sgot_print_fail:
15663           if (data)
15664             free (data);
15665         }
15666       return res;
15667     }
15668
15669   for (entry = dynamic_section;
15670        /* PR 17531 file: 012-50589-0.004.  */
15671        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15672        ++entry)
15673     switch (entry->d_tag)
15674       {
15675       case DT_MIPS_LIBLIST:
15676         liblist_offset
15677           = offset_from_vma (filedata, entry->d_un.d_val,
15678                              liblistno * sizeof (Elf32_External_Lib));
15679         break;
15680       case DT_MIPS_LIBLISTNO:
15681         liblistno = entry->d_un.d_val;
15682         break;
15683       case DT_MIPS_OPTIONS:
15684         options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
15685         break;
15686       case DT_MIPS_CONFLICT:
15687         conflicts_offset
15688           = offset_from_vma (filedata, entry->d_un.d_val,
15689                              conflictsno * sizeof (Elf32_External_Conflict));
15690         break;
15691       case DT_MIPS_CONFLICTNO:
15692         conflictsno = entry->d_un.d_val;
15693         break;
15694       case DT_PLTGOT:
15695         pltgot = entry->d_un.d_ptr;
15696         break;
15697       case DT_MIPS_LOCAL_GOTNO:
15698         local_gotno = entry->d_un.d_val;
15699         break;
15700       case DT_MIPS_GOTSYM:
15701         gotsym = entry->d_un.d_val;
15702         break;
15703       case DT_MIPS_SYMTABNO:
15704         symtabno = entry->d_un.d_val;
15705         break;
15706       case DT_MIPS_PLTGOT:
15707         mips_pltgot = entry->d_un.d_ptr;
15708         break;
15709       case DT_PLTREL:
15710         pltrel = entry->d_un.d_val;
15711         break;
15712       case DT_PLTRELSZ:
15713         pltrelsz = entry->d_un.d_val;
15714         break;
15715       case DT_JMPREL:
15716         jmprel = entry->d_un.d_ptr;
15717         break;
15718       default:
15719         break;
15720       }
15721
15722   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15723     {
15724       Elf32_External_Lib * elib;
15725       size_t cnt;
15726
15727       elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
15728                                               liblistno,
15729                                               sizeof (Elf32_External_Lib),
15730                                               _("liblist section data"));
15731       if (elib)
15732         {
15733           printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15734                             "\nSection '.liblist' contains %lu entries:\n",
15735                             (unsigned long) liblistno),
15736                   (unsigned long) liblistno);
15737           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
15738                  stdout);
15739
15740           for (cnt = 0; cnt < liblistno; ++cnt)
15741             {
15742               Elf32_Lib liblist;
15743               time_t atime;
15744               char timebuf[128];
15745               struct tm * tmp;
15746
15747               liblist.l_name = BYTE_GET (elib[cnt].l_name);
15748               atime = BYTE_GET (elib[cnt].l_time_stamp);
15749               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15750               liblist.l_version = BYTE_GET (elib[cnt].l_version);
15751               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15752
15753               tmp = gmtime (&atime);
15754               snprintf (timebuf, sizeof (timebuf),
15755                         "%04u-%02u-%02uT%02u:%02u:%02u",
15756                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15757                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15758
15759               printf ("%3lu: ", (unsigned long) cnt);
15760               if (VALID_DYNAMIC_NAME (liblist.l_name))
15761                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
15762               else
15763                 printf (_("<corrupt: %9ld>"), liblist.l_name);
15764               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
15765                       liblist.l_version);
15766
15767               if (liblist.l_flags == 0)
15768                 puts (_(" NONE"));
15769               else
15770                 {
15771                   static const struct
15772                   {
15773                     const char * name;
15774                     int bit;
15775                   }
15776                   l_flags_vals[] =
15777                   {
15778                     { " EXACT_MATCH", LL_EXACT_MATCH },
15779                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
15780                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
15781                     { " EXPORTS", LL_EXPORTS },
15782                     { " DELAY_LOAD", LL_DELAY_LOAD },
15783                     { " DELTA", LL_DELTA }
15784                   };
15785                   int flags = liblist.l_flags;
15786                   size_t fcnt;
15787
15788                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
15789                     if ((flags & l_flags_vals[fcnt].bit) != 0)
15790                       {
15791                         fputs (l_flags_vals[fcnt].name, stdout);
15792                         flags ^= l_flags_vals[fcnt].bit;
15793                       }
15794                   if (flags != 0)
15795                     printf (" %#x", (unsigned int) flags);
15796
15797                   puts ("");
15798                 }
15799             }
15800
15801           free (elib);
15802         }
15803       else
15804         res = FALSE;
15805     }
15806
15807   if (options_offset != 0)
15808     {
15809       Elf_External_Options * eopt;
15810       Elf_Internal_Options * iopt;
15811       Elf_Internal_Options * option;
15812       size_t offset;
15813       int cnt;
15814       sect = filedata->section_headers;
15815
15816       /* Find the section header so that we get the size.  */
15817       sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
15818       /* PR 17533 file: 012-277276-0.004.  */
15819       if (sect == NULL)
15820         {
15821           error (_("No MIPS_OPTIONS header found\n"));
15822           return FALSE;
15823         }
15824
15825       eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
15826                                                 sect->sh_size, _("options"));
15827       if (eopt)
15828         {
15829           iopt = (Elf_Internal_Options *)
15830               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
15831           if (iopt == NULL)
15832             {
15833               error (_("Out of memory allocating space for MIPS options\n"));
15834               return FALSE;
15835             }
15836
15837           offset = cnt = 0;
15838           option = iopt;
15839
15840           while (offset <= sect->sh_size - sizeof (* eopt))
15841             {
15842               Elf_External_Options * eoption;
15843
15844               eoption = (Elf_External_Options *) ((char *) eopt + offset);
15845
15846               option->kind = BYTE_GET (eoption->kind);
15847               option->size = BYTE_GET (eoption->size);
15848               option->section = BYTE_GET (eoption->section);
15849               option->info = BYTE_GET (eoption->info);
15850
15851               /* PR 17531: file: ffa0fa3b.  */
15852               if (option->size < sizeof (* eopt)
15853                   || offset + option->size > sect->sh_size)
15854                 {
15855                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
15856                   return FALSE;
15857                 }
15858               offset += option->size;
15859
15860               ++option;
15861               ++cnt;
15862             }
15863
15864           printf (ngettext ("\nSection '%s' contains %d entry:\n",
15865                             "\nSection '%s' contains %d entries:\n",
15866                             cnt),
15867                   printable_section_name (filedata, sect), cnt);
15868
15869           option = iopt;
15870           offset = 0;
15871
15872           while (cnt-- > 0)
15873             {
15874               size_t len;
15875
15876               switch (option->kind)
15877                 {
15878                 case ODK_NULL:
15879                   /* This shouldn't happen.  */
15880                   printf (" NULL       %d %lx", option->section, option->info);
15881                   break;
15882                 case ODK_REGINFO:
15883                   printf (" REGINFO    ");
15884                   if (filedata->file_header.e_machine == EM_MIPS)
15885                     {
15886                       /* 32bit form.  */
15887                       Elf32_External_RegInfo * ereg;
15888                       Elf32_RegInfo reginfo;
15889
15890                       ereg = (Elf32_External_RegInfo *) (option + 1);
15891                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15892                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15893                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15894                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15895                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15896                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
15897
15898                       printf ("GPR %08lx  GP 0x%lx\n",
15899                               reginfo.ri_gprmask,
15900                               (unsigned long) reginfo.ri_gp_value);
15901                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15902                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15903                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15904                     }
15905                   else
15906                     {
15907                       /* 64 bit form.  */
15908                       Elf64_External_RegInfo * ereg;
15909                       Elf64_Internal_RegInfo reginfo;
15910
15911                       ereg = (Elf64_External_RegInfo *) (option + 1);
15912                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
15913                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15914                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15915                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15916                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15917                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
15918
15919                       printf ("GPR %08lx  GP 0x",
15920                               reginfo.ri_gprmask);
15921                       printf_vma (reginfo.ri_gp_value);
15922                       printf ("\n");
15923
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                   ++option;
15929                   continue;
15930                 case ODK_EXCEPTIONS:
15931                   fputs (" EXCEPTIONS fpe_min(", stdout);
15932                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
15933                   fputs (") fpe_max(", stdout);
15934                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
15935                   fputs (")", stdout);
15936
15937                   if (option->info & OEX_PAGE0)
15938                     fputs (" PAGE0", stdout);
15939                   if (option->info & OEX_SMM)
15940                     fputs (" SMM", stdout);
15941                   if (option->info & OEX_FPDBUG)
15942                     fputs (" FPDBUG", stdout);
15943                   if (option->info & OEX_DISMISS)
15944                     fputs (" DISMISS", stdout);
15945                   break;
15946                 case ODK_PAD:
15947                   fputs (" PAD       ", stdout);
15948                   if (option->info & OPAD_PREFIX)
15949                     fputs (" PREFIX", stdout);
15950                   if (option->info & OPAD_POSTFIX)
15951                     fputs (" POSTFIX", stdout);
15952                   if (option->info & OPAD_SYMBOL)
15953                     fputs (" SYMBOL", stdout);
15954                   break;
15955                 case ODK_HWPATCH:
15956                   fputs (" HWPATCH   ", stdout);
15957                   if (option->info & OHW_R4KEOP)
15958                     fputs (" R4KEOP", stdout);
15959                   if (option->info & OHW_R8KPFETCH)
15960                     fputs (" R8KPFETCH", stdout);
15961                   if (option->info & OHW_R5KEOP)
15962                     fputs (" R5KEOP", stdout);
15963                   if (option->info & OHW_R5KCVTL)
15964                     fputs (" R5KCVTL", stdout);
15965                   break;
15966                 case ODK_FILL:
15967                   fputs (" FILL       ", stdout);
15968                   /* XXX Print content of info word?  */
15969                   break;
15970                 case ODK_TAGS:
15971                   fputs (" TAGS       ", stdout);
15972                   /* XXX Print content of info word?  */
15973                   break;
15974                 case ODK_HWAND:
15975                   fputs (" HWAND     ", stdout);
15976                   if (option->info & OHWA0_R4KEOP_CHECKED)
15977                     fputs (" R4KEOP_CHECKED", stdout);
15978                   if (option->info & OHWA0_R4KEOP_CLEAN)
15979                     fputs (" R4KEOP_CLEAN", stdout);
15980                   break;
15981                 case ODK_HWOR:
15982                   fputs (" HWOR      ", stdout);
15983                   if (option->info & OHWA0_R4KEOP_CHECKED)
15984                     fputs (" R4KEOP_CHECKED", stdout);
15985                   if (option->info & OHWA0_R4KEOP_CLEAN)
15986                     fputs (" R4KEOP_CLEAN", stdout);
15987                   break;
15988                 case ODK_GP_GROUP:
15989                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
15990                           option->info & OGP_GROUP,
15991                           (option->info & OGP_SELF) >> 16);
15992                   break;
15993                 case ODK_IDENT:
15994                   printf (" IDENT     %#06lx  self-contained %#06lx",
15995                           option->info & OGP_GROUP,
15996                           (option->info & OGP_SELF) >> 16);
15997                   break;
15998                 default:
15999                   /* This shouldn't happen.  */
16000                   printf (" %3d ???     %d %lx",
16001                           option->kind, option->section, option->info);
16002                   break;
16003                 }
16004
16005               len = sizeof (* eopt);
16006               while (len < option->size)
16007                 {
16008                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
16009
16010                   if (ISPRINT (datum))
16011                     printf ("%c", datum);
16012                   else
16013                     printf ("\\%03o", datum);
16014                   len ++;
16015                 }
16016               fputs ("\n", stdout);
16017
16018               offset += option->size;
16019               ++option;
16020             }
16021
16022           free (eopt);
16023         }
16024       else
16025         res = FALSE;
16026     }
16027
16028   if (conflicts_offset != 0 && conflictsno != 0)
16029     {
16030       Elf32_Conflict * iconf;
16031       size_t cnt;
16032
16033       if (dynamic_symbols == NULL)
16034         {
16035           error (_("conflict list found without a dynamic symbol table\n"));
16036           return FALSE;
16037         }
16038
16039       /* PR 21345 - print a slightly more helpful error message
16040          if we are sure that the cmalloc will fail.  */
16041       if (conflictsno * sizeof (* iconf) > filedata->file_size)
16042         {
16043           error (_("Overlarge number of conflicts detected: %lx\n"),
16044                  (long) conflictsno);
16045           return FALSE;
16046         }
16047
16048       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16049       if (iconf == NULL)
16050         {
16051           error (_("Out of memory allocating space for dynamic conflicts\n"));
16052           return FALSE;
16053         }
16054
16055       if (is_32bit_elf)
16056         {
16057           Elf32_External_Conflict * econf32;
16058
16059           econf32 = (Elf32_External_Conflict *)
16060               get_data (NULL, filedata, conflicts_offset, conflictsno,
16061                         sizeof (* econf32), _("conflict"));
16062           if (!econf32)
16063             return FALSE;
16064
16065           for (cnt = 0; cnt < conflictsno; ++cnt)
16066             iconf[cnt] = BYTE_GET (econf32[cnt]);
16067
16068           free (econf32);
16069         }
16070       else
16071         {
16072           Elf64_External_Conflict * econf64;
16073
16074           econf64 = (Elf64_External_Conflict *)
16075               get_data (NULL, filedata, conflicts_offset, conflictsno,
16076                         sizeof (* econf64), _("conflict"));
16077           if (!econf64)
16078             return FALSE;
16079
16080           for (cnt = 0; cnt < conflictsno; ++cnt)
16081             iconf[cnt] = BYTE_GET (econf64[cnt]);
16082
16083           free (econf64);
16084         }
16085
16086       printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16087                         "\nSection '.conflict' contains %lu entries:\n",
16088                         (unsigned long) conflictsno),
16089               (unsigned long) conflictsno);
16090       puts (_("  Num:    Index       Value  Name"));
16091
16092       for (cnt = 0; cnt < conflictsno; ++cnt)
16093         {
16094           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
16095
16096           if (iconf[cnt] >= num_dynamic_syms)
16097             printf (_("<corrupt symbol index>"));
16098           else
16099             {
16100               Elf_Internal_Sym * psym;
16101
16102               psym = & dynamic_symbols[iconf[cnt]];
16103               print_vma (psym->st_value, FULL_HEX);
16104               putchar (' ');
16105               if (VALID_DYNAMIC_NAME (psym->st_name))
16106                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16107               else
16108                 printf (_("<corrupt: %14ld>"), psym->st_name);
16109             }
16110           putchar ('\n');
16111         }
16112
16113       free (iconf);
16114     }
16115
16116   if (pltgot != 0 && local_gotno != 0)
16117     {
16118       bfd_vma ent, local_end, global_end;
16119       size_t i, offset;
16120       unsigned char * data;
16121       unsigned char * data_end;
16122       int addr_size;
16123
16124       ent = pltgot;
16125       addr_size = (is_32bit_elf ? 4 : 8);
16126       local_end = pltgot + local_gotno * addr_size;
16127
16128       /* PR binutils/17533 file: 012-111227-0.004  */
16129       if (symtabno < gotsym)
16130         {
16131           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16132                  (unsigned long) gotsym, (unsigned long) symtabno);
16133           return FALSE;
16134         }
16135
16136       global_end = local_end + (symtabno - gotsym) * addr_size;
16137       /* PR 17531: file: 54c91a34.  */
16138       if (global_end < local_end)
16139         {
16140           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
16141           return FALSE;
16142         }
16143
16144       offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
16145       data = (unsigned char *) get_data (NULL, filedata, offset,
16146                                          global_end - pltgot, 1,
16147                                          _("Global Offset Table data"));
16148       /* PR 12855: Null data is handled gracefully throughout.  */
16149       data_end = data + (global_end - pltgot);
16150
16151       printf (_("\nPrimary GOT:\n"));
16152       printf (_(" Canonical gp value: "));
16153       print_vma (pltgot + 0x7ff0, LONG_HEX);
16154       printf ("\n\n");
16155
16156       printf (_(" Reserved entries:\n"));
16157       printf (_("  %*s %10s %*s Purpose\n"),
16158               addr_size * 2, _("Address"), _("Access"),
16159               addr_size * 2, _("Initial"));
16160       ent = print_mips_got_entry (data, pltgot, ent, data_end);
16161       printf (_(" Lazy resolver\n"));
16162       if (ent == (bfd_vma) -1)
16163         goto got_print_fail;
16164
16165       /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16166          This entry will be used by some runtime loaders, to store the
16167          module pointer.  Otherwise this is an ordinary local entry.
16168          PR 21344: Check for the entry being fully available before
16169          fetching it.  */
16170       if (data
16171           && data + ent - pltgot + addr_size <= data_end
16172           && (byte_get (data + ent - pltgot, addr_size)
16173               >> (addr_size * 8 - 1)) != 0)
16174         {
16175           ent = print_mips_got_entry (data, pltgot, ent, data_end);
16176           printf (_(" Module pointer (GNU extension)\n"));
16177           if (ent == (bfd_vma) -1)
16178             goto got_print_fail;
16179         }
16180       printf ("\n");
16181
16182       if (data != NULL && ent < local_end)
16183         {
16184           printf (_(" Local entries:\n"));
16185           printf ("  %*s %10s %*s\n",
16186                   addr_size * 2, _("Address"), _("Access"),
16187                   addr_size * 2, _("Initial"));
16188           while (ent < local_end)
16189             {
16190               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16191               printf ("\n");
16192               if (ent == (bfd_vma) -1)
16193                 goto got_print_fail;
16194             }
16195           printf ("\n");
16196         }
16197
16198       if (data != NULL && gotsym < symtabno)
16199         {
16200           int sym_width;
16201
16202           printf (_(" Global entries:\n"));
16203           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
16204                   addr_size * 2, _("Address"),
16205                   _("Access"),
16206                   addr_size * 2, _("Initial"),
16207                   addr_size * 2, _("Sym.Val."),
16208                   _("Type"),
16209                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
16210                   _("Ndx"), _("Name"));
16211
16212           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
16213
16214           for (i = gotsym; i < symtabno; i++)
16215             {
16216               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16217               printf (" ");
16218
16219               if (dynamic_symbols == NULL)
16220                 printf (_("<no dynamic symbols>"));
16221               else if (i < num_dynamic_syms)
16222                 {
16223                   Elf_Internal_Sym * psym = dynamic_symbols + i;
16224
16225                   print_vma (psym->st_value, LONG_HEX);
16226                   printf (" %-7s %3s ",
16227                           get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16228                           get_symbol_index_type (filedata, psym->st_shndx));
16229
16230                   if (VALID_DYNAMIC_NAME (psym->st_name))
16231                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16232                   else
16233                     printf (_("<corrupt: %14ld>"), psym->st_name);
16234                 }
16235               else
16236                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16237                         (unsigned long) i);
16238
16239               printf ("\n");
16240               if (ent == (bfd_vma) -1)
16241                 break;
16242             }
16243           printf ("\n");
16244         }
16245
16246     got_print_fail:
16247       if (data)
16248         free (data);
16249     }
16250
16251   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
16252     {
16253       bfd_vma ent, end;
16254       size_t offset, rel_offset;
16255       unsigned long count, i;
16256       unsigned char * data;
16257       int addr_size, sym_width;
16258       Elf_Internal_Rela * rels;
16259
16260       rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
16261       if (pltrel == DT_RELA)
16262         {
16263           if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16264             return FALSE;
16265         }
16266       else
16267         {
16268           if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16269             return FALSE;
16270         }
16271
16272       ent = mips_pltgot;
16273       addr_size = (is_32bit_elf ? 4 : 8);
16274       end = mips_pltgot + (2 + count) * addr_size;
16275
16276       offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
16277       data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
16278                                          1, _("Procedure Linkage Table data"));
16279       if (data == NULL)
16280         return FALSE;
16281
16282       printf ("\nPLT GOT:\n\n");
16283       printf (_(" Reserved entries:\n"));
16284       printf (_("  %*s %*s Purpose\n"),
16285               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
16286       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16287       printf (_(" PLT lazy resolver\n"));
16288       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16289       printf (_(" Module pointer\n"));
16290       printf ("\n");
16291
16292       printf (_(" Entries:\n"));
16293       printf ("  %*s %*s %*s %-7s %3s %s\n",
16294               addr_size * 2, _("Address"),
16295               addr_size * 2, _("Initial"),
16296               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16297       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
16298       for (i = 0; i < count; i++)
16299         {
16300           unsigned long idx = get_reloc_symindex (rels[i].r_info);
16301
16302           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16303           printf (" ");
16304
16305           if (idx >= num_dynamic_syms)
16306             printf (_("<corrupt symbol index: %lu>"), idx);
16307           else
16308             {
16309               Elf_Internal_Sym * psym = dynamic_symbols + idx;
16310
16311               print_vma (psym->st_value, LONG_HEX);
16312               printf (" %-7s %3s ",
16313                       get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16314                       get_symbol_index_type (filedata, psym->st_shndx));
16315               if (VALID_DYNAMIC_NAME (psym->st_name))
16316                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16317               else
16318                 printf (_("<corrupt: %14ld>"), psym->st_name);
16319             }
16320           printf ("\n");
16321         }
16322       printf ("\n");
16323
16324       if (data)
16325         free (data);
16326       free (rels);
16327     }
16328
16329   return res;
16330 }
16331
16332 static bfd_boolean
16333 process_nds32_specific (Filedata * filedata)
16334 {
16335   Elf_Internal_Shdr *sect = NULL;
16336
16337   sect = find_section (filedata, ".nds32_e_flags");
16338   if (sect != NULL)
16339     {
16340       unsigned int *flag;
16341
16342       printf ("\nNDS32 elf flags section:\n");
16343       flag = get_data (NULL, filedata, sect->sh_offset, 1,
16344                        sect->sh_size, _("NDS32 elf flags section"));
16345
16346       if (! flag)
16347         return FALSE;
16348
16349       switch ((*flag) & 0x3)
16350         {
16351         case 0:
16352           printf ("(VEC_SIZE):\tNo entry.\n");
16353           break;
16354         case 1:
16355           printf ("(VEC_SIZE):\t4 bytes\n");
16356           break;
16357         case 2:
16358           printf ("(VEC_SIZE):\t16 bytes\n");
16359           break;
16360         case 3:
16361           printf ("(VEC_SIZE):\treserved\n");
16362           break;
16363         }
16364     }
16365
16366   return TRUE;
16367 }
16368
16369 static bfd_boolean
16370 process_gnu_liblist (Filedata * filedata)
16371 {
16372   Elf_Internal_Shdr * section;
16373   Elf_Internal_Shdr * string_sec;
16374   Elf32_External_Lib * elib;
16375   char * strtab;
16376   size_t strtab_size;
16377   size_t cnt;
16378   unsigned long num_liblist;
16379   unsigned i;
16380   bfd_boolean res = TRUE;
16381
16382   if (! do_arch)
16383     return TRUE;
16384
16385   for (i = 0, section = filedata->section_headers;
16386        i < filedata->file_header.e_shnum;
16387        i++, section++)
16388     {
16389       switch (section->sh_type)
16390         {
16391         case SHT_GNU_LIBLIST:
16392           if (section->sh_link >= filedata->file_header.e_shnum)
16393             break;
16394
16395           elib = (Elf32_External_Lib *)
16396               get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
16397                         _("liblist section data"));
16398
16399           if (elib == NULL)
16400             {
16401               res = FALSE;
16402               break;
16403             }
16404
16405           string_sec = filedata->section_headers + section->sh_link;
16406           strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
16407                                       string_sec->sh_size,
16408                                       _("liblist string table"));
16409           if (strtab == NULL
16410               || section->sh_entsize != sizeof (Elf32_External_Lib))
16411             {
16412               free (elib);
16413               free (strtab);
16414               res = FALSE;
16415               break;
16416             }
16417           strtab_size = string_sec->sh_size;
16418
16419           num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
16420           printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16421                             "\nLibrary list section '%s' contains %lu entries:\n",
16422                             num_liblist),
16423                   printable_section_name (filedata, section),
16424                   num_liblist);
16425
16426           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
16427
16428           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16429                ++cnt)
16430             {
16431               Elf32_Lib liblist;
16432               time_t atime;
16433               char timebuf[128];
16434               struct tm * tmp;
16435
16436               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16437               atime = BYTE_GET (elib[cnt].l_time_stamp);
16438               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16439               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16440               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16441
16442               tmp = gmtime (&atime);
16443               snprintf (timebuf, sizeof (timebuf),
16444                         "%04u-%02u-%02uT%02u:%02u:%02u",
16445                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16446                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16447
16448               printf ("%3lu: ", (unsigned long) cnt);
16449               if (do_wide)
16450                 printf ("%-20s", liblist.l_name < strtab_size
16451                         ? strtab + liblist.l_name : _("<corrupt>"));
16452               else
16453                 printf ("%-20.20s", liblist.l_name < strtab_size
16454                         ? strtab + liblist.l_name : _("<corrupt>"));
16455               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16456                       liblist.l_version, liblist.l_flags);
16457             }
16458
16459           free (elib);
16460           free (strtab);
16461         }
16462     }
16463
16464   return res;
16465 }
16466
16467 static const char *
16468 get_note_type (Filedata * filedata, unsigned e_type)
16469 {
16470   static char buff[64];
16471
16472   if (filedata->file_header.e_type == ET_CORE)
16473     switch (e_type)
16474       {
16475       case NT_AUXV:
16476         return _("NT_AUXV (auxiliary vector)");
16477       case NT_PRSTATUS:
16478         return _("NT_PRSTATUS (prstatus structure)");
16479       case NT_FPREGSET:
16480         return _("NT_FPREGSET (floating point registers)");
16481       case NT_PRPSINFO:
16482         return _("NT_PRPSINFO (prpsinfo structure)");
16483       case NT_TASKSTRUCT:
16484         return _("NT_TASKSTRUCT (task structure)");
16485       case NT_PRXFPREG:
16486         return _("NT_PRXFPREG (user_xfpregs structure)");
16487       case NT_PPC_VMX:
16488         return _("NT_PPC_VMX (ppc Altivec registers)");
16489       case NT_PPC_VSX:
16490         return _("NT_PPC_VSX (ppc VSX registers)");
16491       case NT_PPC_TAR:
16492         return _("NT_PPC_TAR (ppc TAR register)");
16493       case NT_PPC_PPR:
16494         return _("NT_PPC_PPR (ppc PPR register)");
16495       case NT_PPC_DSCR:
16496         return _("NT_PPC_DSCR (ppc DSCR register)");
16497       case NT_PPC_EBB:
16498         return _("NT_PPC_EBB (ppc EBB registers)");
16499       case NT_PPC_PMU:
16500         return _("NT_PPC_PMU (ppc PMU registers)");
16501       case NT_PPC_TM_CGPR:
16502         return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16503       case NT_PPC_TM_CFPR:
16504         return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16505       case NT_PPC_TM_CVMX:
16506         return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16507       case NT_PPC_TM_CVSX:
16508         return _("NT_PPC_TM_VSX (ppc checkpointed VSX registers)");
16509       case NT_PPC_TM_SPR:
16510         return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16511       case NT_PPC_TM_CTAR:
16512         return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16513       case NT_PPC_TM_CPPR:
16514         return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16515       case NT_PPC_TM_CDSCR:
16516         return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16517       case NT_386_TLS:
16518         return _("NT_386_TLS (x86 TLS information)");
16519       case NT_386_IOPERM:
16520         return _("NT_386_IOPERM (x86 I/O permissions)");
16521       case NT_X86_XSTATE:
16522         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16523       case NT_S390_HIGH_GPRS:
16524         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16525       case NT_S390_TIMER:
16526         return _("NT_S390_TIMER (s390 timer register)");
16527       case NT_S390_TODCMP:
16528         return _("NT_S390_TODCMP (s390 TOD comparator register)");
16529       case NT_S390_TODPREG:
16530         return _("NT_S390_TODPREG (s390 TOD programmable register)");
16531       case NT_S390_CTRS:
16532         return _("NT_S390_CTRS (s390 control registers)");
16533       case NT_S390_PREFIX:
16534         return _("NT_S390_PREFIX (s390 prefix register)");
16535       case NT_S390_LAST_BREAK:
16536         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16537       case NT_S390_SYSTEM_CALL:
16538         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16539       case NT_S390_TDB:
16540         return _("NT_S390_TDB (s390 transaction diagnostic block)");
16541       case NT_S390_VXRS_LOW:
16542         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16543       case NT_S390_VXRS_HIGH:
16544         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16545       case NT_S390_GS_CB:
16546         return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16547       case NT_S390_GS_BC:
16548         return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16549       case NT_ARM_VFP:
16550         return _("NT_ARM_VFP (arm VFP registers)");
16551       case NT_ARM_TLS:
16552         return _("NT_ARM_TLS (AArch TLS registers)");
16553       case NT_ARM_HW_BREAK:
16554         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16555       case NT_ARM_HW_WATCH:
16556         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16557       case NT_PSTATUS:
16558         return _("NT_PSTATUS (pstatus structure)");
16559       case NT_FPREGS:
16560         return _("NT_FPREGS (floating point registers)");
16561       case NT_PSINFO:
16562         return _("NT_PSINFO (psinfo structure)");
16563       case NT_LWPSTATUS:
16564         return _("NT_LWPSTATUS (lwpstatus_t structure)");
16565       case NT_LWPSINFO:
16566         return _("NT_LWPSINFO (lwpsinfo_t structure)");
16567       case NT_WIN32PSTATUS:
16568         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16569       case NT_SIGINFO:
16570         return _("NT_SIGINFO (siginfo_t data)");
16571       case NT_FILE:
16572         return _("NT_FILE (mapped files)");
16573       default:
16574         break;
16575       }
16576   else
16577     switch (e_type)
16578       {
16579       case NT_VERSION:
16580         return _("NT_VERSION (version)");
16581       case NT_ARCH:
16582         return _("NT_ARCH (architecture)");
16583       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16584         return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16585       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16586         return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16587       default:
16588         break;
16589       }
16590
16591   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16592   return buff;
16593 }
16594
16595 static bfd_boolean
16596 print_core_note (Elf_Internal_Note *pnote)
16597 {
16598   unsigned int addr_size = is_32bit_elf ? 4 : 8;
16599   bfd_vma count, page_size;
16600   unsigned char *descdata, *filenames, *descend;
16601
16602   if (pnote->type != NT_FILE)
16603     {
16604       if (do_wide)
16605         printf ("\n");
16606       return TRUE;
16607     }
16608
16609 #ifndef BFD64
16610   if (!is_32bit_elf)
16611     {
16612       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
16613       /* Still "successful".  */
16614       return TRUE;
16615     }
16616 #endif
16617
16618   if (pnote->descsz < 2 * addr_size)
16619     {
16620       error (_("    Malformed note - too short for header\n"));
16621       return FALSE;
16622     }
16623
16624   descdata = (unsigned char *) pnote->descdata;
16625   descend = descdata + pnote->descsz;
16626
16627   if (descdata[pnote->descsz - 1] != '\0')
16628     {
16629       error (_("    Malformed note - does not end with \\0\n"));
16630       return FALSE;
16631     }
16632
16633   count = byte_get (descdata, addr_size);
16634   descdata += addr_size;
16635
16636   page_size = byte_get (descdata, addr_size);
16637   descdata += addr_size;
16638
16639   if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
16640       || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16641     {
16642       error (_("    Malformed note - too short for supplied file count\n"));
16643       return FALSE;
16644     }
16645
16646   printf (_("    Page size: "));
16647   print_vma (page_size, DEC);
16648   printf ("\n");
16649
16650   printf (_("    %*s%*s%*s\n"),
16651           (int) (2 + 2 * addr_size), _("Start"),
16652           (int) (4 + 2 * addr_size), _("End"),
16653           (int) (4 + 2 * addr_size), _("Page Offset"));
16654   filenames = descdata + count * 3 * addr_size;
16655   while (count-- > 0)
16656     {
16657       bfd_vma start, end, file_ofs;
16658
16659       if (filenames == descend)
16660         {
16661           error (_("    Malformed note - filenames end too early\n"));
16662           return FALSE;
16663         }
16664
16665       start = byte_get (descdata, addr_size);
16666       descdata += addr_size;
16667       end = byte_get (descdata, addr_size);
16668       descdata += addr_size;
16669       file_ofs = byte_get (descdata, addr_size);
16670       descdata += addr_size;
16671
16672       printf ("    ");
16673       print_vma (start, FULL_HEX);
16674       printf ("  ");
16675       print_vma (end, FULL_HEX);
16676       printf ("  ");
16677       print_vma (file_ofs, FULL_HEX);
16678       printf ("\n        %s\n", filenames);
16679
16680       filenames += 1 + strlen ((char *) filenames);
16681     }
16682
16683   return TRUE;
16684 }
16685
16686 static const char *
16687 get_gnu_elf_note_type (unsigned e_type)
16688 {
16689   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
16690   switch (e_type)
16691     {
16692     case NT_GNU_ABI_TAG:
16693       return _("NT_GNU_ABI_TAG (ABI version tag)");
16694     case NT_GNU_HWCAP:
16695       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16696     case NT_GNU_BUILD_ID:
16697       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16698     case NT_GNU_GOLD_VERSION:
16699       return _("NT_GNU_GOLD_VERSION (gold version)");
16700     case NT_GNU_PROPERTY_TYPE_0:
16701       return _("NT_GNU_PROPERTY_TYPE_0");
16702     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16703       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16704     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16705       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16706     default:
16707       {
16708         static char buff[64];
16709
16710         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16711         return buff;
16712       }
16713     }
16714 }
16715
16716 static void
16717 decode_x86_isa (unsigned int bitmask)
16718 {
16719   while (bitmask)
16720     {
16721       unsigned int bit = bitmask & (- bitmask);
16722
16723       bitmask &= ~ bit;
16724       switch (bit)
16725         {
16726         case GNU_PROPERTY_X86_ISA_1_486: printf ("i486"); break;
16727         case GNU_PROPERTY_X86_ISA_1_586: printf ("586"); break;
16728         case GNU_PROPERTY_X86_ISA_1_686: printf ("686"); break;
16729         case GNU_PROPERTY_X86_ISA_1_SSE: printf ("SSE"); break;
16730         case GNU_PROPERTY_X86_ISA_1_SSE2: printf ("SSE2"); break;
16731         case GNU_PROPERTY_X86_ISA_1_SSE3: printf ("SSE3"); break;
16732         case GNU_PROPERTY_X86_ISA_1_SSSE3: printf ("SSSE3"); break;
16733         case GNU_PROPERTY_X86_ISA_1_SSE4_1: printf ("SSE4_1"); break;
16734         case GNU_PROPERTY_X86_ISA_1_SSE4_2: printf ("SSE4_2"); break;
16735         case GNU_PROPERTY_X86_ISA_1_AVX: printf ("AVX"); break;
16736         case GNU_PROPERTY_X86_ISA_1_AVX2: printf ("AVX2"); break;
16737         case GNU_PROPERTY_X86_ISA_1_AVX512F: printf ("AVX512F"); break;
16738         case GNU_PROPERTY_X86_ISA_1_AVX512CD: printf ("AVX512CD"); break;
16739         case GNU_PROPERTY_X86_ISA_1_AVX512ER: printf ("AVX512ER"); break;
16740         case GNU_PROPERTY_X86_ISA_1_AVX512PF: printf ("AVX512PF"); break;
16741         case GNU_PROPERTY_X86_ISA_1_AVX512VL: printf ("AVX512VL"); break;
16742         case GNU_PROPERTY_X86_ISA_1_AVX512DQ: printf ("AVX512DQ"); break;
16743         case GNU_PROPERTY_X86_ISA_1_AVX512BW: printf ("AVX512BW"); break;
16744         default: printf (_("<unknown: %x>"), bit); break;
16745         }
16746       if (bitmask)
16747         printf (", ");
16748     }
16749 }
16750
16751 static void
16752 decode_x86_feature (unsigned int type, unsigned int bitmask)
16753 {
16754   while (bitmask)
16755     {
16756       unsigned int bit = bitmask & (- bitmask);
16757
16758       bitmask &= ~ bit;
16759       switch (bit)
16760         {
16761         case GNU_PROPERTY_X86_FEATURE_1_IBT:
16762           switch (type)
16763             {
16764             case GNU_PROPERTY_X86_FEATURE_1_AND:
16765               printf ("IBT");
16766               break;
16767             default:
16768               /* This should never happen.  */
16769               abort ();
16770             }
16771           break;
16772         case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
16773           switch (type)
16774             {
16775             case GNU_PROPERTY_X86_FEATURE_1_AND:
16776               printf ("SHSTK");
16777               break;
16778             default:
16779               /* This should never happen.  */
16780               abort ();
16781             }
16782           break;
16783         default:
16784           printf (_("<unknown: %x>"), bit);
16785           break;
16786         }
16787       if (bitmask)
16788         printf (", ");
16789     }
16790 }
16791
16792 static void
16793 print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
16794 {
16795   unsigned char * ptr = (unsigned char *) pnote->descdata;
16796   unsigned char * ptr_end = ptr + pnote->descsz;
16797   unsigned int    size = is_32bit_elf ? 4 : 8;
16798
16799   printf (_("      Properties: "));
16800
16801   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
16802     {
16803       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
16804       return;
16805     }
16806
16807   while (ptr < ptr_end)
16808     {
16809       unsigned int j;
16810       unsigned int type;
16811       unsigned int datasz;
16812
16813       if ((size_t) (ptr_end - ptr) < 8)
16814         {
16815           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
16816           break;
16817         }
16818
16819       type = byte_get (ptr, 4);
16820       datasz = byte_get (ptr + 4, 4);
16821
16822       ptr += 8;
16823
16824       if (datasz > (size_t) (ptr_end - ptr))
16825         {
16826           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16827                   type, datasz);
16828           break;
16829         }
16830
16831       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
16832         {
16833           if (filedata->file_header.e_machine == EM_X86_64
16834               || filedata->file_header.e_machine == EM_IAMCU
16835               || filedata->file_header.e_machine == EM_386)
16836             {
16837               switch (type)
16838                 {
16839                 case GNU_PROPERTY_X86_ISA_1_USED:
16840                   printf ("x86 ISA used: ");
16841                   if (datasz != 4)
16842                     printf (_("<corrupt length: %#x> "), datasz);
16843                   else
16844                     decode_x86_isa (byte_get (ptr, 4));
16845                   goto next;
16846
16847                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
16848                   printf ("x86 ISA needed: ");
16849                   if (datasz != 4)
16850                     printf (_("<corrupt length: %#x> "), datasz);
16851                   else
16852                     decode_x86_isa (byte_get (ptr, 4));
16853                   goto next;
16854
16855                 case GNU_PROPERTY_X86_FEATURE_1_AND:
16856                   printf ("x86 feature: ");
16857                   if (datasz != 4)
16858                     printf (_("<corrupt length: %#x> "), datasz);
16859                   else
16860                     decode_x86_feature (type, byte_get (ptr, 4));
16861                   goto next;
16862
16863                 default:
16864                   break;
16865                 }
16866             }
16867         }
16868       else
16869         {
16870           switch (type)
16871             {
16872             case GNU_PROPERTY_STACK_SIZE:
16873               printf (_("stack size: "));
16874               if (datasz != size)
16875                 printf (_("<corrupt length: %#x> "), datasz);
16876               else
16877                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
16878               goto next;
16879
16880             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
16881               printf ("no copy on protected ");
16882               if (datasz)
16883                 printf (_("<corrupt length: %#x> "), datasz);
16884               goto next;
16885
16886             default:
16887               break;
16888             }
16889         }
16890
16891       if (type < GNU_PROPERTY_LOPROC)
16892         printf (_("<unknown type %#x data: "), type);
16893       else if (type < GNU_PROPERTY_LOUSER)
16894         printf (_("<procesor-specific type %#x data: "), type);
16895       else
16896         printf (_("<application-specific type %#x data: "), type);
16897       for (j = 0; j < datasz; ++j)
16898         printf ("%02x ", ptr[j] & 0xff);
16899       printf (">");
16900
16901 next:
16902       ptr += ((datasz + (size - 1)) & ~ (size - 1));
16903       if (ptr == ptr_end)
16904         break;
16905
16906       if (do_wide)
16907         printf (", ");
16908       else
16909         printf ("\n\t");
16910     }
16911
16912   printf ("\n");
16913 }
16914
16915 static bfd_boolean
16916 print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
16917 {
16918   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
16919   switch (pnote->type)
16920     {
16921     case NT_GNU_BUILD_ID:
16922       {
16923         unsigned long i;
16924
16925         printf (_("    Build ID: "));
16926         for (i = 0; i < pnote->descsz; ++i)
16927           printf ("%02x", pnote->descdata[i] & 0xff);
16928         printf ("\n");
16929       }
16930       break;
16931
16932     case NT_GNU_ABI_TAG:
16933       {
16934         unsigned long os, major, minor, subminor;
16935         const char *osname;
16936
16937         /* PR 17531: file: 030-599401-0.004.  */
16938         if (pnote->descsz < 16)
16939           {
16940             printf (_("    <corrupt GNU_ABI_TAG>\n"));
16941             break;
16942           }
16943
16944         os = byte_get ((unsigned char *) pnote->descdata, 4);
16945         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16946         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
16947         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
16948
16949         switch (os)
16950           {
16951           case GNU_ABI_TAG_LINUX:
16952             osname = "Linux";
16953             break;
16954           case GNU_ABI_TAG_HURD:
16955             osname = "Hurd";
16956             break;
16957           case GNU_ABI_TAG_SOLARIS:
16958             osname = "Solaris";
16959             break;
16960           case GNU_ABI_TAG_FREEBSD:
16961             osname = "FreeBSD";
16962             break;
16963           case GNU_ABI_TAG_NETBSD:
16964             osname = "NetBSD";
16965             break;
16966           case GNU_ABI_TAG_SYLLABLE:
16967             osname = "Syllable";
16968             break;
16969           case GNU_ABI_TAG_NACL:
16970             osname = "NaCl";
16971             break;
16972           default:
16973             osname = "Unknown";
16974             break;
16975           }
16976
16977         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
16978                 major, minor, subminor);
16979       }
16980       break;
16981
16982     case NT_GNU_GOLD_VERSION:
16983       {
16984         unsigned long i;
16985
16986         printf (_("    Version: "));
16987         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
16988           printf ("%c", pnote->descdata[i]);
16989         printf ("\n");
16990       }
16991       break;
16992
16993     case NT_GNU_HWCAP:
16994       {
16995         unsigned long num_entries, mask;
16996
16997         /* Hardware capabilities information.  Word 0 is the number of entries.
16998            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
16999            is a series of entries, where each entry is a single byte followed
17000            by a nul terminated string.  The byte gives the bit number to test
17001            if enabled in the bitmask.  */
17002         printf (_("      Hardware Capabilities: "));
17003         if (pnote->descsz < 8)
17004           {
17005             error (_("<corrupt GNU_HWCAP>\n"));
17006             return FALSE;
17007           }
17008         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
17009         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17010         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
17011         /* FIXME: Add code to display the entries... */
17012       }
17013       break;
17014
17015     case NT_GNU_PROPERTY_TYPE_0:
17016       print_gnu_property_note (filedata, pnote);
17017       break;
17018
17019     default:
17020       /* Handle unrecognised types.  An error message should have already been
17021          created by get_gnu_elf_note_type(), so all that we need to do is to
17022          display the data.  */
17023       {
17024         unsigned long i;
17025
17026         printf (_("    Description data: "));
17027         for (i = 0; i < pnote->descsz; ++i)
17028           printf ("%02x ", pnote->descdata[i] & 0xff);
17029         printf ("\n");
17030       }
17031       break;
17032     }
17033
17034   return TRUE;
17035 }
17036
17037 static const char *
17038 get_v850_elf_note_type (enum v850_notes n_type)
17039 {
17040   static char buff[64];
17041
17042   switch (n_type)
17043     {
17044     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
17045     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
17046     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
17047     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
17048     case V850_NOTE_CACHE_INFO: return _("Use of cache");
17049     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
17050     default:
17051       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
17052       return buff;
17053     }
17054 }
17055
17056 static bfd_boolean
17057 print_v850_note (Elf_Internal_Note * pnote)
17058 {
17059   unsigned int val;
17060
17061   if (pnote->descsz != 4)
17062     return FALSE;
17063
17064   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
17065
17066   if (val == 0)
17067     {
17068       printf (_("not set\n"));
17069       return TRUE;
17070     }
17071
17072   switch (pnote->type)
17073     {
17074     case V850_NOTE_ALIGNMENT:
17075       switch (val)
17076         {
17077         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
17078         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
17079         }
17080       break;
17081
17082     case V850_NOTE_DATA_SIZE:
17083       switch (val)
17084         {
17085         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
17086         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
17087         }
17088       break;
17089
17090     case V850_NOTE_FPU_INFO:
17091       switch (val)
17092         {
17093         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
17094         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
17095         }
17096       break;
17097
17098     case V850_NOTE_MMU_INFO:
17099     case V850_NOTE_CACHE_INFO:
17100     case V850_NOTE_SIMD_INFO:
17101       if (val == EF_RH850_SIMD)
17102         {
17103           printf (_("yes\n"));
17104           return TRUE;
17105         }
17106       break;
17107
17108     default:
17109       /* An 'unknown note type' message will already have been displayed.  */
17110       break;
17111     }
17112
17113   printf (_("unknown value: %x\n"), val);
17114   return FALSE;
17115 }
17116
17117 static bfd_boolean
17118 process_netbsd_elf_note (Elf_Internal_Note * pnote)
17119 {
17120   unsigned int version;
17121
17122   switch (pnote->type)
17123     {
17124     case NT_NETBSD_IDENT:
17125       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
17126       if ((version / 10000) % 100)
17127         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
17128                 version, version / 100000000, (version / 1000000) % 100,
17129                 (version / 10000) % 100 > 26 ? "Z" : "",
17130                 'A' + (version / 10000) % 26);
17131       else
17132         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
17133                 version, version / 100000000, (version / 1000000) % 100,
17134                 (version / 100) % 100);
17135       return TRUE;
17136
17137     case NT_NETBSD_MARCH:
17138       printf ("  NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
17139               pnote->descdata);
17140       return TRUE;
17141
17142     default:
17143       printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
17144               pnote->type);
17145       return FALSE;
17146     }
17147 }
17148
17149 static const char *
17150 get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17151 {
17152   switch (e_type)
17153     {
17154     case NT_FREEBSD_THRMISC:
17155       return _("NT_THRMISC (thrmisc structure)");
17156     case NT_FREEBSD_PROCSTAT_PROC:
17157       return _("NT_PROCSTAT_PROC (proc data)");
17158     case NT_FREEBSD_PROCSTAT_FILES:
17159       return _("NT_PROCSTAT_FILES (files data)");
17160     case NT_FREEBSD_PROCSTAT_VMMAP:
17161       return _("NT_PROCSTAT_VMMAP (vmmap data)");
17162     case NT_FREEBSD_PROCSTAT_GROUPS:
17163       return _("NT_PROCSTAT_GROUPS (groups data)");
17164     case NT_FREEBSD_PROCSTAT_UMASK:
17165       return _("NT_PROCSTAT_UMASK (umask data)");
17166     case NT_FREEBSD_PROCSTAT_RLIMIT:
17167       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17168     case NT_FREEBSD_PROCSTAT_OSREL:
17169       return _("NT_PROCSTAT_OSREL (osreldate data)");
17170     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
17171       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17172     case NT_FREEBSD_PROCSTAT_AUXV:
17173       return _("NT_PROCSTAT_AUXV (auxv data)");
17174     case NT_FREEBSD_PTLWPINFO:
17175       return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17176     }
17177   return get_note_type (filedata, e_type);
17178 }
17179
17180 static const char *
17181 get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17182 {
17183   static char buff[64];
17184
17185   if (e_type == NT_NETBSDCORE_PROCINFO)
17186     return _("NetBSD procinfo structure");
17187
17188   /* As of Jan 2002 there are no other machine-independent notes
17189      defined for NetBSD core files.  If the note type is less
17190      than the start of the machine-dependent note types, we don't
17191      understand it.  */
17192
17193   if (e_type < NT_NETBSDCORE_FIRSTMACH)
17194     {
17195       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17196       return buff;
17197     }
17198
17199   switch (filedata->file_header.e_machine)
17200     {
17201     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17202        and PT_GETFPREGS == mach+2.  */
17203
17204     case EM_OLD_ALPHA:
17205     case EM_ALPHA:
17206     case EM_SPARC:
17207     case EM_SPARC32PLUS:
17208     case EM_SPARCV9:
17209       switch (e_type)
17210         {
17211         case NT_NETBSDCORE_FIRSTMACH + 0:
17212           return _("PT_GETREGS (reg structure)");
17213         case NT_NETBSDCORE_FIRSTMACH + 2:
17214           return _("PT_GETFPREGS (fpreg structure)");
17215         default:
17216           break;
17217         }
17218       break;
17219
17220     /* On all other arch's, PT_GETREGS == mach+1 and
17221        PT_GETFPREGS == mach+3.  */
17222     default:
17223       switch (e_type)
17224         {
17225         case NT_NETBSDCORE_FIRSTMACH + 1:
17226           return _("PT_GETREGS (reg structure)");
17227         case NT_NETBSDCORE_FIRSTMACH + 3:
17228           return _("PT_GETFPREGS (fpreg structure)");
17229         default:
17230           break;
17231         }
17232     }
17233
17234   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
17235             e_type - NT_NETBSDCORE_FIRSTMACH);
17236   return buff;
17237 }
17238
17239 static const char *
17240 get_stapsdt_note_type (unsigned e_type)
17241 {
17242   static char buff[64];
17243
17244   switch (e_type)
17245     {
17246     case NT_STAPSDT:
17247       return _("NT_STAPSDT (SystemTap probe descriptors)");
17248
17249     default:
17250       break;
17251     }
17252
17253   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17254   return buff;
17255 }
17256
17257 static bfd_boolean
17258 print_stapsdt_note (Elf_Internal_Note *pnote)
17259 {
17260   int addr_size = is_32bit_elf ? 4 : 8;
17261   char *data = pnote->descdata;
17262   char *data_end = pnote->descdata + pnote->descsz;
17263   bfd_vma pc, base_addr, semaphore;
17264   char *provider, *probe, *arg_fmt;
17265
17266   pc = byte_get ((unsigned char *) data, addr_size);
17267   data += addr_size;
17268   base_addr = byte_get ((unsigned char *) data, addr_size);
17269   data += addr_size;
17270   semaphore = byte_get ((unsigned char *) data, addr_size);
17271   data += addr_size;
17272
17273   provider = data;
17274   data += strlen (data) + 1;
17275   probe = data;
17276   data += strlen (data) + 1;
17277   arg_fmt = data;
17278   data += strlen (data) + 1;
17279
17280   printf (_("    Provider: %s\n"), provider);
17281   printf (_("    Name: %s\n"), probe);
17282   printf (_("    Location: "));
17283   print_vma (pc, FULL_HEX);
17284   printf (_(", Base: "));
17285   print_vma (base_addr, FULL_HEX);
17286   printf (_(", Semaphore: "));
17287   print_vma (semaphore, FULL_HEX);
17288   printf ("\n");
17289   printf (_("    Arguments: %s\n"), arg_fmt);
17290
17291   return data == data_end;
17292 }
17293
17294 static const char *
17295 get_ia64_vms_note_type (unsigned e_type)
17296 {
17297   static char buff[64];
17298
17299   switch (e_type)
17300     {
17301     case NT_VMS_MHD:
17302       return _("NT_VMS_MHD (module header)");
17303     case NT_VMS_LNM:
17304       return _("NT_VMS_LNM (language name)");
17305     case NT_VMS_SRC:
17306       return _("NT_VMS_SRC (source files)");
17307     case NT_VMS_TITLE:
17308       return "NT_VMS_TITLE";
17309     case NT_VMS_EIDC:
17310       return _("NT_VMS_EIDC (consistency check)");
17311     case NT_VMS_FPMODE:
17312       return _("NT_VMS_FPMODE (FP mode)");
17313     case NT_VMS_LINKTIME:
17314       return "NT_VMS_LINKTIME";
17315     case NT_VMS_IMGNAM:
17316       return _("NT_VMS_IMGNAM (image name)");
17317     case NT_VMS_IMGID:
17318       return _("NT_VMS_IMGID (image id)");
17319     case NT_VMS_LINKID:
17320       return _("NT_VMS_LINKID (link id)");
17321     case NT_VMS_IMGBID:
17322       return _("NT_VMS_IMGBID (build id)");
17323     case NT_VMS_GSTNAM:
17324       return _("NT_VMS_GSTNAM (sym table name)");
17325     case NT_VMS_ORIG_DYN:
17326       return "NT_VMS_ORIG_DYN";
17327     case NT_VMS_PATCHTIME:
17328       return "NT_VMS_PATCHTIME";
17329     default:
17330       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17331       return buff;
17332     }
17333 }
17334
17335 static bfd_boolean
17336 print_ia64_vms_note (Elf_Internal_Note * pnote)
17337 {
17338   switch (pnote->type)
17339     {
17340     case NT_VMS_MHD:
17341       if (pnote->descsz > 36)
17342         {
17343           size_t l = strlen (pnote->descdata + 34);
17344           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
17345           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
17346           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
17347           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
17348         }
17349       else
17350         printf (_("    Invalid size\n"));
17351       break;
17352     case NT_VMS_LNM:
17353       printf (_("   Language: %s\n"), pnote->descdata);
17354       break;
17355 #ifdef BFD64
17356     case NT_VMS_FPMODE:
17357       printf (_("   Floating Point mode: "));
17358       printf ("0x%016" BFD_VMA_FMT "x\n",
17359               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
17360       break;
17361     case NT_VMS_LINKTIME:
17362       printf (_("   Link time: "));
17363       print_vms_time
17364         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17365       printf ("\n");
17366       break;
17367     case NT_VMS_PATCHTIME:
17368       printf (_("   Patch time: "));
17369       print_vms_time
17370         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17371       printf ("\n");
17372       break;
17373     case NT_VMS_ORIG_DYN:
17374       printf (_("   Major id: %u,  minor id: %u\n"),
17375               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
17376               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
17377       printf (_("   Last modified  : "));
17378       print_vms_time
17379         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
17380       printf (_("\n   Link flags  : "));
17381       printf ("0x%016" BFD_VMA_FMT "x\n",
17382               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
17383       printf (_("   Header flags: 0x%08x\n"),
17384               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
17385       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
17386       break;
17387 #endif
17388     case NT_VMS_IMGNAM:
17389       printf (_("    Image name: %s\n"), pnote->descdata);
17390       break;
17391     case NT_VMS_GSTNAM:
17392       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
17393       break;
17394     case NT_VMS_IMGID:
17395       printf (_("    Image id: %s\n"), pnote->descdata);
17396       break;
17397     case NT_VMS_LINKID:
17398       printf (_("    Linker id: %s\n"), pnote->descdata);
17399       break;
17400     default:
17401       return FALSE;
17402     }
17403   return TRUE;
17404 }
17405
17406 /* Print the name of the symbol associated with a build attribute
17407    that is attached to address OFFSET.  */
17408
17409 static bfd_boolean
17410 print_symbol_for_build_attribute (Filedata *     filedata,
17411                                   unsigned long  offset,
17412                                   bfd_boolean    is_open_attr)
17413 {
17414   static Filedata *         saved_filedata = NULL;
17415   static char *             strtab;
17416   static unsigned long      strtablen;
17417   static Elf_Internal_Sym * symtab;
17418   static unsigned long      nsyms;
17419   Elf_Internal_Sym *        saved_sym = NULL;
17420   Elf_Internal_Sym *        sym;
17421
17422   if (filedata->section_headers != NULL
17423       && (saved_filedata == NULL || filedata != saved_filedata))
17424     {
17425       Elf_Internal_Shdr * symsec;
17426
17427       /* Load the symbol and string sections.  */
17428       for (symsec = filedata->section_headers;
17429            symsec < filedata->section_headers + filedata->file_header.e_shnum;
17430            symsec ++)
17431         {
17432           if (symsec->sh_type == SHT_SYMTAB)
17433             {
17434               symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
17435
17436               if (symsec->sh_link < filedata->file_header.e_shnum)
17437                 {
17438                   Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
17439
17440                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
17441                                               1, strtab_sec->sh_size,
17442                                               _("string table"));
17443                   strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
17444                 }
17445             }
17446         }
17447       saved_filedata = filedata;
17448     }
17449
17450   if (symtab == NULL || strtab == NULL)
17451     {
17452       printf ("\n");
17453       return FALSE;
17454     }
17455
17456   /* Find a symbol whose value matches offset.  */
17457   for (sym = symtab; sym < symtab + nsyms; sym ++)
17458     if (sym->st_value == offset)
17459       {
17460         if (sym->st_name >= strtablen)
17461           /* Huh ?  This should not happen.  */
17462           continue;
17463
17464         if (strtab[sym->st_name] == 0)
17465           continue;
17466
17467         if (is_open_attr)
17468           {
17469             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17470                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
17471                FUNC symbols entirely.  */
17472             switch (ELF_ST_TYPE (sym->st_info))
17473               {
17474               case STT_FILE:
17475                 saved_sym = sym;
17476                 /* We can stop searching now.  */
17477                 sym = symtab + nsyms;
17478                 continue;
17479
17480               case STT_OBJECT:
17481                 saved_sym = sym;
17482                 continue;
17483
17484               case STT_FUNC:
17485                 /* Ignore function symbols.  */
17486                 continue;
17487
17488               default:
17489                 break;
17490               }
17491
17492             switch (ELF_ST_BIND (sym->st_info))
17493               {
17494               case STB_GLOBAL:
17495                 if (saved_sym == NULL
17496                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
17497                   saved_sym = sym;
17498                 break;
17499
17500               case STB_LOCAL:
17501                 if (saved_sym == NULL)
17502                   saved_sym = sym;
17503                 break;
17504
17505               default:
17506                 break;
17507               }
17508           }
17509         else
17510           {
17511             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
17512               continue;
17513
17514             saved_sym = sym;
17515             break;
17516           }
17517       }
17518
17519   printf (" (%s: %s)\n",
17520           is_open_attr ? _("file") : _("func"),
17521           saved_sym ? strtab + saved_sym->st_name : _("<no symbol found>)"));
17522   return TRUE;
17523 }
17524
17525 static bfd_boolean
17526 print_gnu_build_attribute_description (Elf_Internal_Note *  pnote,
17527                                        Filedata *           filedata)
17528 {
17529   static unsigned long global_offset = 0;
17530   unsigned long        offset;
17531   unsigned int         desc_size = is_32bit_elf ? 4 : 8;
17532   bfd_boolean          is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
17533
17534   if (pnote->descsz == 0)
17535     {
17536       if (is_open_attr)
17537         {
17538           printf (_("    Applies from offset %#lx\n"), global_offset);
17539           return TRUE;
17540         }
17541       else
17542         {
17543           printf (_("    Applies to func at %#lx"), global_offset);
17544           return print_symbol_for_build_attribute (filedata, global_offset, is_open_attr);
17545         }
17546     }
17547
17548   if (pnote->descsz != desc_size)
17549     {
17550       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
17551       printf (_("    <invalid descsz>"));
17552       return FALSE;
17553     }
17554
17555   offset = byte_get ((unsigned char *) pnote->descdata, desc_size);
17556
17557   if (is_open_attr)
17558     {
17559       printf (_("    Applies from offset %#lx"), offset);
17560       global_offset = offset;
17561     }
17562   else
17563     {
17564       printf (_("    Applies to func at %#lx"), offset);
17565     }
17566
17567   return print_symbol_for_build_attribute (filedata, offset, is_open_attr);
17568 }
17569
17570 static bfd_boolean
17571 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
17572 {
17573   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
17574   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
17575   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
17576   char         name_type;
17577   char         name_attribute;
17578   const char * expected_types;
17579   const char * name = pnote->namedata;
17580   const char * text;
17581   signed int   left;
17582
17583   if (name == NULL || pnote->namesz < 2)
17584     {
17585       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17586       print_symbol (-20, _("  <corrupt name>"));
17587       return FALSE;
17588     }
17589
17590   left = 20;
17591
17592   /* Version 2 of the spec adds a "GA" prefix to the name field.  */
17593   if (name[0] == 'G' && name[1] == 'A')
17594     {
17595       printf ("GA");
17596       name += 2;
17597       left -= 2;
17598     }
17599
17600   switch ((name_type = * name))
17601     {
17602     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17603     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17604     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17605     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17606       printf ("%c", * name);
17607       left --;
17608       break;
17609     default:
17610       error (_("unrecognised attribute type in name field: %d\n"), name_type);
17611       print_symbol (-20, _("<unknown name type>"));
17612       return FALSE;
17613     }
17614
17615   ++ name;
17616   text = NULL;
17617
17618   switch ((name_attribute = * name))
17619     {
17620     case GNU_BUILD_ATTRIBUTE_VERSION:
17621       text = _("<version>");
17622       expected_types = string_expected;
17623       ++ name;
17624       break;
17625     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17626       text = _("<stack prot>");
17627       expected_types = "!+*";
17628       ++ name;
17629       break;
17630     case GNU_BUILD_ATTRIBUTE_RELRO:
17631       text = _("<relro>");
17632       expected_types = bool_expected;
17633       ++ name;
17634       break;
17635     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
17636       text = _("<stack size>");
17637       expected_types = number_expected;
17638       ++ name;
17639       break;
17640     case GNU_BUILD_ATTRIBUTE_TOOL:
17641       text = _("<tool>");
17642       expected_types = string_expected;
17643       ++ name;
17644       break;
17645     case GNU_BUILD_ATTRIBUTE_ABI:
17646       text = _("<ABI>");
17647       expected_types = "$*";
17648       ++ name;
17649       break;
17650     case GNU_BUILD_ATTRIBUTE_PIC:
17651       text = _("<PIC>");
17652       expected_types = number_expected;
17653       ++ name;
17654       break;
17655     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
17656       text = _("<short enum>");
17657       expected_types = bool_expected;
17658       ++ name;
17659       break;
17660     default:
17661       if (ISPRINT (* name))
17662         {
17663           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
17664
17665           if (len > left && ! do_wide)
17666             len = left;
17667           printf ("%.*s:", len, name);
17668           left -= len;
17669           name += len;
17670         }
17671       else
17672         {
17673           static char tmpbuf [128];
17674
17675           error (_("unrecognised byte in name field: %d\n"), * name);
17676           sprintf (tmpbuf, _("<unknown:_%d>"), * name);
17677           text = tmpbuf;
17678           name ++;
17679         }
17680       expected_types = "*$!+";
17681       break;
17682     }
17683
17684   if (text)
17685     left -= printf ("%s", text);
17686
17687   if (strchr (expected_types, name_type) == NULL)
17688     warn (_("attribute does not have an expected type (%c)\n"), name_type);
17689
17690   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
17691     {
17692       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17693              (unsigned long) pnote->namesz,
17694              (long) (name - pnote->namedata));
17695       return FALSE;
17696     }
17697
17698   if (left < 1 && ! do_wide)
17699     return TRUE;
17700
17701   switch (name_type)
17702     {
17703     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17704       {
17705         unsigned int        bytes;
17706         unsigned long long  val = 0;
17707         unsigned int        shift = 0;
17708         char *              decoded = NULL;
17709
17710         bytes = pnote->namesz - (name - pnote->namedata);
17711         if (bytes > 0)
17712           /* The -1 is because the name field is always 0 terminated, and we
17713              want to be able to ensure that the shift in the while loop below
17714              will not overflow.  */
17715           -- bytes;
17716
17717         if (bytes > sizeof (val))
17718           {
17719             error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17720                    bytes);
17721             bytes = sizeof (val);
17722           }
17723         /* We do not bother to warn if bytes == 0 as this can
17724            happen with some early versions of the gcc plugin.  */
17725
17726         while (bytes --)
17727           {
17728             unsigned long byte = (* name ++) & 0xff;
17729
17730             val |= byte << shift;
17731             shift += 8;
17732           }
17733
17734         switch (name_attribute)
17735           {
17736           case GNU_BUILD_ATTRIBUTE_PIC:
17737             switch (val)
17738               {
17739               case 0: decoded = "static"; break;
17740               case 1: decoded = "pic"; break;
17741               case 2: decoded = "PIC"; break;
17742               case 3: decoded = "pie"; break;
17743               case 4: decoded = "PIE"; break;
17744               default: break;
17745               }
17746             break;
17747           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17748             switch (val)
17749               {
17750                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
17751               case 0: decoded = "off"; break;
17752               case 1: decoded = "on"; break;
17753               case 2: decoded = "all"; break;
17754               case 3: decoded = "strong"; break;
17755               case 4: decoded = "explicit"; break;
17756               default: break;
17757               }
17758             break;
17759           default:
17760             break;
17761           }
17762
17763         if (decoded != NULL)
17764           {
17765             print_symbol (-left, decoded);
17766             left = 0;
17767           }
17768         else if (val == 0)
17769           {
17770             printf ("0x0");
17771             left -= 3;
17772           }
17773         else
17774           {
17775             if (do_wide)
17776               left -= printf ("0x%llx", val);
17777             else
17778               left -= printf ("0x%-.*llx", left, val);
17779           }
17780       }
17781       break;
17782     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17783       left -= print_symbol (- left, name);
17784       break;
17785     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17786       left -= print_symbol (- left, "true");
17787       break;
17788     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17789       left -= print_symbol (- left, "false");
17790       break;
17791     }
17792
17793   if (do_wide && left > 0)
17794     printf ("%-*s", left, " ");
17795
17796   return TRUE;
17797 }
17798
17799 /* Note that by the ELF standard, the name field is already null byte
17800    terminated, and namesz includes the terminating null byte.
17801    I.E. the value of namesz for the name "FSF" is 4.
17802
17803    If the value of namesz is zero, there is no name present.  */
17804
17805 static bfd_boolean
17806 process_note (Elf_Internal_Note *  pnote,
17807               Filedata *           filedata)
17808 {
17809   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
17810   const char * nt;
17811
17812   if (pnote->namesz == 0)
17813     /* If there is no note name, then use the default set of
17814        note type strings.  */
17815     nt = get_note_type (filedata, pnote->type);
17816
17817   else if (const_strneq (pnote->namedata, "GNU"))
17818     /* GNU-specific object file notes.  */
17819     nt = get_gnu_elf_note_type (pnote->type);
17820
17821   else if (const_strneq (pnote->namedata, "FreeBSD"))
17822     /* FreeBSD-specific core file notes.  */
17823     nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
17824
17825   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
17826     /* NetBSD-specific core file notes.  */
17827     nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
17828
17829   else if (const_strneq (pnote->namedata, "NetBSD"))
17830     /* NetBSD-specific core file notes.  */
17831     return process_netbsd_elf_note (pnote);
17832
17833   else if (strneq (pnote->namedata, "SPU/", 4))
17834     {
17835       /* SPU-specific core file notes.  */
17836       nt = pnote->namedata + 4;
17837       name = "SPU";
17838     }
17839
17840   else if (const_strneq (pnote->namedata, "IPF/VMS"))
17841     /* VMS/ia64-specific file notes.  */
17842     nt = get_ia64_vms_note_type (pnote->type);
17843
17844   else if (const_strneq (pnote->namedata, "stapsdt"))
17845     nt = get_stapsdt_note_type (pnote->type);
17846
17847   else
17848     /* Don't recognize this note name; just use the default set of
17849        note type strings.  */
17850     nt = get_note_type (filedata, pnote->type);
17851
17852   printf ("  ");
17853
17854   if (((const_strneq (pnote->namedata, "GA")
17855         && strchr ("*$!+", pnote->namedata[2]) != NULL)
17856        || strchr ("*$!+", pnote->namedata[0]) != NULL)
17857       && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17858           || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
17859     print_gnu_build_attribute_name (pnote);
17860   else
17861     print_symbol (-20, name);
17862
17863   if (do_wide)
17864     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
17865   else
17866     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
17867
17868   if (const_strneq (pnote->namedata, "IPF/VMS"))
17869     return print_ia64_vms_note (pnote);
17870   else if (const_strneq (pnote->namedata, "GNU"))
17871     return print_gnu_note (filedata, pnote);
17872   else if (const_strneq (pnote->namedata, "stapsdt"))
17873     return print_stapsdt_note (pnote);
17874   else if (const_strneq (pnote->namedata, "CORE"))
17875     return print_core_note (pnote);
17876   else if (((const_strneq (pnote->namedata, "GA")
17877              && strchr ("*$!+", pnote->namedata[2]) != NULL)
17878             || strchr ("*$!+", pnote->namedata[0]) != NULL)
17879            && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17880                || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
17881     return print_gnu_build_attribute_description (pnote, filedata);
17882
17883   if (pnote->descsz)
17884     {
17885       unsigned long i;
17886
17887       printf (_("   description data: "));
17888       for (i = 0; i < pnote->descsz; i++)
17889         printf ("%02x ", pnote->descdata[i]);
17890       if (!do_wide)
17891         printf ("\n");
17892     }
17893
17894   if (do_wide)
17895     printf ("\n");
17896
17897   return TRUE;
17898 }
17899
17900 static bfd_boolean
17901 process_notes_at (Filedata *           filedata,
17902                   Elf_Internal_Shdr *  section,
17903                   bfd_vma              offset,
17904                   bfd_vma              length)
17905 {
17906   Elf_External_Note * pnotes;
17907   Elf_External_Note * external;
17908   char * end;
17909   bfd_boolean res = TRUE;
17910
17911   if (length <= 0)
17912     return FALSE;
17913
17914   if (section)
17915     {
17916       pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
17917       if (pnotes)
17918         {
17919           if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
17920             return FALSE;
17921         }
17922     }
17923   else
17924     pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
17925                                              _("notes"));
17926   if (pnotes == NULL)
17927     return FALSE;
17928
17929   external = pnotes;
17930
17931   if (section)
17932     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
17933   else
17934     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
17935             (unsigned long) offset, (unsigned long) length);
17936
17937   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
17938
17939   end = (char *) pnotes + length;
17940   while ((char *) external < end)
17941     {
17942       Elf_Internal_Note inote;
17943       size_t min_notesz;
17944       char *next;
17945       char * temp = NULL;
17946       size_t data_remaining = end - (char *) external;
17947
17948       if (!is_ia64_vms (filedata))
17949         {
17950           /* PR binutils/15191
17951              Make sure that there is enough data to read.  */
17952           min_notesz = offsetof (Elf_External_Note, name);
17953           if (data_remaining < min_notesz)
17954             {
17955               warn (ngettext ("Corrupt note: only %ld byte remains, "
17956                               "not enough for a full note\n",
17957                               "Corrupt note: only %ld bytes remain, "
17958                               "not enough for a full note\n",
17959                               data_remaining),
17960                     (long) data_remaining);
17961               break;
17962             }
17963           data_remaining -= min_notesz;
17964
17965           inote.type     = BYTE_GET (external->type);
17966           inote.namesz   = BYTE_GET (external->namesz);
17967           inote.namedata = external->name;
17968           inote.descsz   = BYTE_GET (external->descsz);
17969           inote.descdata = inote.namedata + align_power (inote.namesz, 2);
17970           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
17971           next = inote.descdata + align_power (inote.descsz, 2);
17972         }
17973       else
17974         {
17975           Elf64_External_VMS_Note *vms_external;
17976
17977           /* PR binutils/15191
17978              Make sure that there is enough data to read.  */
17979           min_notesz = offsetof (Elf64_External_VMS_Note, name);
17980           if (data_remaining < min_notesz)
17981             {
17982               warn (ngettext ("Corrupt note: only %ld byte remains, "
17983                               "not enough for a full note\n",
17984                               "Corrupt note: only %ld bytes remain, "
17985                               "not enough for a full note\n",
17986                               data_remaining),
17987                     (long) data_remaining);
17988               break;
17989             }
17990           data_remaining -= min_notesz;
17991
17992           vms_external = (Elf64_External_VMS_Note *) external;
17993           inote.type     = BYTE_GET (vms_external->type);
17994           inote.namesz   = BYTE_GET (vms_external->namesz);
17995           inote.namedata = vms_external->name;
17996           inote.descsz   = BYTE_GET (vms_external->descsz);
17997           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
17998           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
17999           next = inote.descdata + align_power (inote.descsz, 3);
18000         }
18001
18002       /* PR 17531: file: 3443835e.  */
18003       /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
18004       if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
18005           || (size_t) (inote.descdata - inote.namedata) > data_remaining
18006           || (size_t) (next - inote.descdata) < inote.descsz
18007           || ((size_t) (next - inote.descdata)
18008               > data_remaining - (size_t) (inote.descdata - inote.namedata)))
18009         {
18010           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18011                 (unsigned long) ((char *) external - (char *) pnotes));
18012           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
18013                 inote.type, inote.namesz, inote.descsz);
18014           break;
18015         }
18016
18017       external = (Elf_External_Note *) next;
18018
18019       /* Verify that name is null terminated.  It appears that at least
18020          one version of Linux (RedHat 6.0) generates corefiles that don't
18021          comply with the ELF spec by failing to include the null byte in
18022          namesz.  */
18023       if (inote.namedata[inote.namesz - 1] != '\0')
18024         {
18025           if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
18026             {
18027               temp = (char *) malloc (inote.namesz + 1);
18028               if (temp == NULL)
18029                 {
18030                   error (_("Out of memory allocating space for inote name\n"));
18031                   res = FALSE;
18032                   break;
18033                 }
18034
18035               memcpy (temp, inote.namedata, inote.namesz);
18036               inote.namedata = temp;
18037             }
18038           inote.namedata[inote.namesz] = 0;
18039         }
18040
18041       if (! process_note (& inote, filedata))
18042         res = FALSE;
18043
18044       if (temp != NULL)
18045         {
18046           free (temp);
18047           temp = NULL;
18048         }
18049     }
18050
18051   free (pnotes);
18052
18053   return res;
18054 }
18055
18056 static bfd_boolean
18057 process_corefile_note_segments (Filedata * filedata)
18058 {
18059   Elf_Internal_Phdr * segment;
18060   unsigned int i;
18061   bfd_boolean res = TRUE;
18062
18063   if (! get_program_headers (filedata))
18064     return TRUE;
18065
18066   for (i = 0, segment = filedata->program_headers;
18067        i < filedata->file_header.e_phnum;
18068        i++, segment++)
18069     {
18070       if (segment->p_type == PT_NOTE)
18071         if (! process_notes_at (filedata, NULL,
18072                                 (bfd_vma) segment->p_offset,
18073                                 (bfd_vma) segment->p_filesz))
18074           res = FALSE;
18075     }
18076
18077   return res;
18078 }
18079
18080 static bfd_boolean
18081 process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
18082 {
18083   Elf_External_Note * pnotes;
18084   Elf_External_Note * external;
18085   char * end;
18086   bfd_boolean res = TRUE;
18087
18088   if (length <= 0)
18089     return FALSE;
18090
18091   pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18092                                            _("v850 notes"));
18093   if (pnotes == NULL)
18094     return FALSE;
18095
18096   external = pnotes;
18097   end = (char*) pnotes + length;
18098
18099   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18100           (unsigned long) offset, (unsigned long) length);
18101
18102   while ((char *) external + sizeof (Elf_External_Note) < end)
18103     {
18104       Elf_External_Note * next;
18105       Elf_Internal_Note inote;
18106
18107       inote.type     = BYTE_GET (external->type);
18108       inote.namesz   = BYTE_GET (external->namesz);
18109       inote.namedata = external->name;
18110       inote.descsz   = BYTE_GET (external->descsz);
18111       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
18112       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18113
18114       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
18115         {
18116           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
18117           inote.descdata = inote.namedata;
18118           inote.namesz   = 0;
18119         }
18120
18121       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
18122
18123       if (   ((char *) next > end)
18124           || ((char *) next <  (char *) pnotes))
18125         {
18126           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18127                 (unsigned long) ((char *) external - (char *) pnotes));
18128           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18129                 inote.type, inote.namesz, inote.descsz);
18130           break;
18131         }
18132
18133       external = next;
18134
18135       /* Prevent out-of-bounds indexing.  */
18136       if (   inote.namedata + inote.namesz > end
18137           || inote.namedata + inote.namesz < inote.namedata)
18138         {
18139           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18140                 (unsigned long) ((char *) external - (char *) pnotes));
18141           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18142                 inote.type, inote.namesz, inote.descsz);
18143           break;
18144         }
18145
18146       printf ("  %s: ", get_v850_elf_note_type (inote.type));
18147
18148       if (! print_v850_note (& inote))
18149         {
18150           res = FALSE;
18151           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18152                   inote.namesz, inote.descsz);
18153         }
18154     }
18155
18156   free (pnotes);
18157
18158   return res;
18159 }
18160
18161 static bfd_boolean
18162 process_note_sections (Filedata * filedata)
18163 {
18164   Elf_Internal_Shdr * section;
18165   unsigned long i;
18166   unsigned int n = 0;
18167   bfd_boolean res = TRUE;
18168
18169   for (i = 0, section = filedata->section_headers;
18170        i < filedata->file_header.e_shnum && section != NULL;
18171        i++, section++)
18172     {
18173       if (section->sh_type == SHT_NOTE)
18174         {
18175           if (! process_notes_at (filedata, section,
18176                                   (bfd_vma) section->sh_offset,
18177                                   (bfd_vma) section->sh_size))
18178             res = FALSE;
18179           n++;
18180         }
18181
18182       if ((   filedata->file_header.e_machine == EM_V800
18183            || filedata->file_header.e_machine == EM_V850
18184            || filedata->file_header.e_machine == EM_CYGNUS_V850)
18185           && section->sh_type == SHT_RENESAS_INFO)
18186         {
18187           if (! process_v850_notes (filedata,
18188                                     (bfd_vma) section->sh_offset,
18189                                     (bfd_vma) section->sh_size))
18190             res = FALSE;
18191           n++;
18192         }
18193     }
18194
18195   if (n == 0)
18196     /* Try processing NOTE segments instead.  */
18197     return process_corefile_note_segments (filedata);
18198
18199   return res;
18200 }
18201
18202 static bfd_boolean
18203 process_notes (Filedata * filedata)
18204 {
18205   /* If we have not been asked to display the notes then do nothing.  */
18206   if (! do_notes)
18207     return TRUE;
18208
18209   if (filedata->file_header.e_type != ET_CORE)
18210     return process_note_sections (filedata);
18211
18212   /* No program headers means no NOTE segment.  */
18213   if (filedata->file_header.e_phnum > 0)
18214     return process_corefile_note_segments (filedata);
18215
18216   printf (_("No note segments present in the core file.\n"));
18217   return TRUE;
18218 }
18219
18220 static unsigned char *
18221 display_public_gnu_attributes (unsigned char * start,
18222                                const unsigned char * const end)
18223 {
18224   printf (_("  Unknown GNU attribute: %s\n"), start);
18225
18226   start += strnlen ((char *) start, end - start);
18227   display_raw_attribute (start, end);
18228
18229   return (unsigned char *) end;
18230 }
18231
18232 static unsigned char *
18233 display_generic_attribute (unsigned char * start,
18234                            unsigned int tag,
18235                            const unsigned char * const end)
18236 {
18237   if (tag == 0)
18238     return (unsigned char *) end;
18239
18240   return display_tag_value (tag, start, end);
18241 }
18242
18243 static bfd_boolean
18244 process_arch_specific (Filedata * filedata)
18245 {
18246   if (! do_arch)
18247     return TRUE;
18248
18249   switch (filedata->file_header.e_machine)
18250     {
18251     case EM_ARC:
18252     case EM_ARC_COMPACT:
18253     case EM_ARC_COMPACT2:
18254       return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
18255                                  display_arc_attribute,
18256                                  display_generic_attribute);
18257     case EM_ARM:
18258       return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
18259                                  display_arm_attribute,
18260                                  display_generic_attribute);
18261
18262     case EM_MIPS:
18263     case EM_MIPS_RS3_LE:
18264       return process_mips_specific (filedata);
18265
18266     case EM_MSP430:
18267      return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
18268                                 display_msp430x_attribute,
18269                                 display_generic_attribute);
18270
18271     case EM_NDS32:
18272       return process_nds32_specific (filedata);
18273
18274     case EM_PPC:
18275     case EM_PPC64:
18276       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18277                                  display_power_gnu_attribute);
18278
18279     case EM_S390:
18280     case EM_S390_OLD:
18281       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18282                                  display_s390_gnu_attribute);
18283
18284     case EM_SPARC:
18285     case EM_SPARC32PLUS:
18286     case EM_SPARCV9:
18287       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18288                                  display_sparc_gnu_attribute);
18289
18290     case EM_TI_C6000:
18291       return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
18292                                  display_tic6x_attribute,
18293                                  display_generic_attribute);
18294
18295     default:
18296       return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
18297                                  display_public_gnu_attributes,
18298                                  display_generic_attribute);
18299     }
18300 }
18301
18302 static bfd_boolean
18303 get_file_header (Filedata * filedata)
18304 {
18305   /* Read in the identity array.  */
18306   if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
18307     return FALSE;
18308
18309   /* Determine how to read the rest of the header.  */
18310   switch (filedata->file_header.e_ident[EI_DATA])
18311     {
18312     default:
18313     case ELFDATANONE:
18314     case ELFDATA2LSB:
18315       byte_get = byte_get_little_endian;
18316       byte_put = byte_put_little_endian;
18317       break;
18318     case ELFDATA2MSB:
18319       byte_get = byte_get_big_endian;
18320       byte_put = byte_put_big_endian;
18321       break;
18322     }
18323
18324   /* For now we only support 32 bit and 64 bit ELF files.  */
18325   is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
18326
18327   /* Read in the rest of the header.  */
18328   if (is_32bit_elf)
18329     {
18330       Elf32_External_Ehdr ehdr32;
18331
18332       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
18333         return FALSE;
18334
18335       filedata->file_header.e_type      = BYTE_GET (ehdr32.e_type);
18336       filedata->file_header.e_machine   = BYTE_GET (ehdr32.e_machine);
18337       filedata->file_header.e_version   = BYTE_GET (ehdr32.e_version);
18338       filedata->file_header.e_entry     = BYTE_GET (ehdr32.e_entry);
18339       filedata->file_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
18340       filedata->file_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
18341       filedata->file_header.e_flags     = BYTE_GET (ehdr32.e_flags);
18342       filedata->file_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
18343       filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
18344       filedata->file_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
18345       filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
18346       filedata->file_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
18347       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
18348     }
18349   else
18350     {
18351       Elf64_External_Ehdr ehdr64;
18352
18353       /* If we have been compiled with sizeof (bfd_vma) == 4, then
18354          we will not be able to cope with the 64bit data found in
18355          64 ELF files.  Detect this now and abort before we start
18356          overwriting things.  */
18357       if (sizeof (bfd_vma) < 8)
18358         {
18359           error (_("This instance of readelf has been built without support for a\n\
18360 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18361           return FALSE;
18362         }
18363
18364       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
18365         return FALSE;
18366
18367       filedata->file_header.e_type      = BYTE_GET (ehdr64.e_type);
18368       filedata->file_header.e_machine   = BYTE_GET (ehdr64.e_machine);
18369       filedata->file_header.e_version   = BYTE_GET (ehdr64.e_version);
18370       filedata->file_header.e_entry     = BYTE_GET (ehdr64.e_entry);
18371       filedata->file_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
18372       filedata->file_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
18373       filedata->file_header.e_flags     = BYTE_GET (ehdr64.e_flags);
18374       filedata->file_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
18375       filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
18376       filedata->file_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
18377       filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
18378       filedata->file_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
18379       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
18380     }
18381
18382   if (filedata->file_header.e_shoff)
18383     {
18384       /* There may be some extensions in the first section header.  Don't
18385          bomb if we can't read it.  */
18386       if (is_32bit_elf)
18387         get_32bit_section_headers (filedata, TRUE);
18388       else
18389         get_64bit_section_headers (filedata, TRUE);
18390     }
18391
18392   return TRUE;
18393 }
18394
18395 static void
18396 close_file (Filedata * filedata)
18397 {
18398   if (filedata)
18399     {
18400       if (filedata->handle)
18401         fclose (filedata->handle);
18402       free (filedata);
18403     }
18404 }
18405
18406 void
18407 close_debug_file (void * data)
18408 {
18409   close_file ((Filedata *) data);
18410 }
18411
18412 static Filedata *
18413 open_file (const char * pathname)
18414 {
18415   struct stat  statbuf;
18416   Filedata *   filedata = NULL;
18417
18418   if (stat (pathname, & statbuf) < 0
18419       || ! S_ISREG (statbuf.st_mode))
18420     goto fail;
18421
18422   filedata = calloc (1, sizeof * filedata);
18423   if (filedata == NULL)
18424     goto fail;
18425
18426   filedata->handle = fopen (pathname, "rb");
18427   if (filedata->handle == NULL)
18428     goto fail;
18429
18430   filedata->file_size = (bfd_size_type) statbuf.st_size;
18431   filedata->file_name = pathname;
18432
18433   if (! get_file_header (filedata))
18434     goto fail;
18435
18436   if (filedata->file_header.e_shoff)
18437     {
18438       bfd_boolean res;
18439
18440       /* Read the section headers again, this time for real.  */
18441       if (is_32bit_elf)
18442         res = get_32bit_section_headers (filedata, FALSE);
18443       else
18444         res = get_64bit_section_headers (filedata, FALSE);
18445
18446       if (!res)
18447         goto fail;
18448     }
18449
18450   return filedata;
18451
18452  fail:
18453   if (filedata)
18454     {
18455       if (filedata->handle)
18456         fclose (filedata->handle);
18457       free (filedata);
18458     }
18459   return NULL;
18460 }
18461
18462 void *
18463 open_debug_file (const char * pathname)
18464 {
18465   return open_file (pathname);
18466 }
18467
18468 /* Process one ELF object file according to the command line options.
18469    This file may actually be stored in an archive.  The file is
18470    positioned at the start of the ELF object.  Returns TRUE if no
18471    problems were encountered, FALSE otherwise.  */
18472
18473 static bfd_boolean
18474 process_object (Filedata * filedata)
18475 {
18476   Filedata * separates;
18477   unsigned int i;
18478   bfd_boolean res = TRUE;
18479
18480   if (! get_file_header (filedata))
18481     {
18482       error (_("%s: Failed to read file header\n"), filedata->file_name);
18483       return FALSE;
18484     }
18485
18486   /* Initialise per file variables.  */
18487   for (i = ARRAY_SIZE (version_info); i--;)
18488     version_info[i] = 0;
18489
18490   for (i = ARRAY_SIZE (dynamic_info); i--;)
18491     dynamic_info[i] = 0;
18492   dynamic_info_DT_GNU_HASH = 0;
18493
18494   /* Process the file.  */
18495   if (show_name)
18496     printf (_("\nFile: %s\n"), filedata->file_name);
18497
18498   /* Initialise the dump_sects array from the cmdline_dump_sects array.
18499      Note we do this even if cmdline_dump_sects is empty because we
18500      must make sure that the dump_sets array is zeroed out before each
18501      object file is processed.  */
18502   if (filedata->num_dump_sects > cmdline.num_dump_sects)
18503     memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
18504
18505   if (cmdline.num_dump_sects > 0)
18506     {
18507       if (filedata->num_dump_sects == 0)
18508         /* A sneaky way of allocating the dump_sects array.  */
18509         request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
18510
18511       assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
18512       memcpy (filedata->dump_sects, cmdline.dump_sects,
18513               cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
18514     }
18515
18516   if (! process_file_header (filedata))
18517     return FALSE;
18518
18519   if (! process_section_headers (filedata))
18520     {
18521       /* Without loaded section headers we cannot process lots of things.  */
18522       do_unwind = do_version = do_dump = do_arch = FALSE;
18523
18524       if (! do_using_dynamic)
18525         do_syms = do_dyn_syms = do_reloc = FALSE;
18526     }
18527
18528   if (! process_section_groups (filedata))
18529     /* Without loaded section groups we cannot process unwind.  */
18530     do_unwind = FALSE;
18531
18532   if (process_program_headers (filedata))
18533     process_dynamic_section (filedata);
18534   else
18535     res = FALSE;
18536
18537   if (! process_relocs (filedata))
18538     res = FALSE;
18539
18540   if (! process_unwind (filedata))
18541     res = FALSE;
18542
18543   if (! process_symbol_table (filedata))
18544     res = FALSE;
18545
18546   if (! process_syminfo (filedata))
18547     res = FALSE;
18548
18549   if (! process_version_sections (filedata))
18550     res = FALSE;
18551
18552   separates = load_separate_debug_file (filedata, filedata->file_name);
18553
18554   if (! process_section_contents (filedata))
18555     res = FALSE;
18556
18557   if (separates)
18558     {
18559       if (! process_section_headers (separates))
18560         res = FALSE;
18561       else if (! process_section_contents (separates))
18562         res = FALSE;
18563     }
18564
18565   if (! process_notes (filedata))
18566     res = FALSE;
18567
18568   if (! process_gnu_liblist (filedata))
18569     res = FALSE;
18570
18571   if (! process_arch_specific (filedata))
18572     res = FALSE;
18573
18574   free (filedata->program_headers);
18575   filedata->program_headers = NULL;
18576
18577   free (filedata->section_headers);
18578   filedata->section_headers = NULL;
18579
18580   free (filedata->string_table);
18581   filedata->string_table = NULL;
18582   filedata->string_table_length = 0;
18583
18584   if (dynamic_strings)
18585     {
18586       free (dynamic_strings);
18587       dynamic_strings = NULL;
18588       dynamic_strings_length = 0;
18589     }
18590
18591   if (dynamic_symbols)
18592     {
18593       free (dynamic_symbols);
18594       dynamic_symbols = NULL;
18595       num_dynamic_syms = 0;
18596     }
18597
18598   if (dynamic_syminfo)
18599     {
18600       free (dynamic_syminfo);
18601       dynamic_syminfo = NULL;
18602     }
18603
18604   if (dynamic_section)
18605     {
18606       free (dynamic_section);
18607       dynamic_section = NULL;
18608     }
18609
18610   if (section_headers_groups)
18611     {
18612       free (section_headers_groups);
18613       section_headers_groups = NULL;
18614     }
18615
18616   if (section_groups)
18617     {
18618       struct group_list * g;
18619       struct group_list * next;
18620
18621       for (i = 0; i < group_count; i++)
18622         {
18623           for (g = section_groups [i].root; g != NULL; g = next)
18624             {
18625               next = g->next;
18626               free (g);
18627             }
18628         }
18629
18630       free (section_groups);
18631       section_groups = NULL;
18632     }
18633
18634   free_debug_memory ();
18635
18636   return res;
18637 }
18638
18639 /* Process an ELF archive.
18640    On entry the file is positioned just after the ARMAG string.
18641    Returns TRUE upon success, FALSE otherwise.  */
18642
18643 static bfd_boolean
18644 process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
18645 {
18646   struct archive_info arch;
18647   struct archive_info nested_arch;
18648   size_t got;
18649   bfd_boolean ret = TRUE;
18650
18651   show_name = TRUE;
18652
18653   /* The ARCH structure is used to hold information about this archive.  */
18654   arch.file_name = NULL;
18655   arch.file = NULL;
18656   arch.index_array = NULL;
18657   arch.sym_table = NULL;
18658   arch.longnames = NULL;
18659
18660   /* The NESTED_ARCH structure is used as a single-item cache of information
18661      about a nested archive (when members of a thin archive reside within
18662      another regular archive file).  */
18663   nested_arch.file_name = NULL;
18664   nested_arch.file = NULL;
18665   nested_arch.index_array = NULL;
18666   nested_arch.sym_table = NULL;
18667   nested_arch.longnames = NULL;
18668
18669   if (setup_archive (&arch, filedata->file_name, filedata->handle,
18670                      is_thin_archive, do_archive_index) != 0)
18671     {
18672       ret = FALSE;
18673       goto out;
18674     }
18675
18676   if (do_archive_index)
18677     {
18678       if (arch.sym_table == NULL)
18679         error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
18680       else
18681         {
18682           unsigned long i, l;
18683           unsigned long current_pos;
18684
18685           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18686                   filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
18687
18688           current_pos = ftell (filedata->handle);
18689
18690           for (i = l = 0; i < arch.index_num; i++)
18691             {
18692               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
18693                 {
18694                   char * member_name;
18695
18696                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
18697
18698                   if (member_name != NULL)
18699                     {
18700                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
18701
18702                       if (qualified_name != NULL)
18703                         {
18704                           printf (_("Contents of binary %s at offset "), qualified_name);
18705                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
18706                           putchar ('\n');
18707                           free (qualified_name);
18708                         }
18709                     }
18710                 }
18711
18712               if (l >= arch.sym_size)
18713                 {
18714                   error (_("%s: end of the symbol table reached before the end of the index\n"),
18715                          filedata->file_name);
18716                   ret = FALSE;
18717                   break;
18718                 }
18719               /* PR 17531: file: 0b6630b2.  */
18720               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
18721               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
18722             }
18723
18724           if (arch.uses_64bit_indicies)
18725             l = (l + 7) & ~ 7;
18726           else
18727             l += l & 1;
18728
18729           if (l < arch.sym_size)
18730             {
18731               error (ngettext ("%s: %ld byte remains in the symbol table, "
18732                                "but without corresponding entries in "
18733                                "the index table\n",
18734                                "%s: %ld bytes remain in the symbol table, "
18735                                "but without corresponding entries in "
18736                                "the index table\n",
18737                                arch.sym_size - l),
18738                      filedata->file_name, arch.sym_size - l);
18739               ret = FALSE;
18740             }
18741
18742           if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
18743             {
18744               error (_("%s: failed to seek back to start of object files in the archive\n"),
18745                      filedata->file_name);
18746               ret = FALSE;
18747               goto out;
18748             }
18749         }
18750
18751       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
18752           && !do_segments && !do_header && !do_dump && !do_version
18753           && !do_histogram && !do_debugging && !do_arch && !do_notes
18754           && !do_section_groups && !do_dyn_syms)
18755         {
18756           ret = TRUE; /* Archive index only.  */
18757           goto out;
18758         }
18759     }
18760
18761   while (1)
18762     {
18763       char * name;
18764       size_t namelen;
18765       char * qualified_name;
18766
18767       /* Read the next archive header.  */
18768       if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
18769         {
18770           error (_("%s: failed to seek to next archive header\n"), filedata->file_name);
18771           return FALSE;
18772         }
18773       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
18774       if (got != sizeof arch.arhdr)
18775         {
18776           if (got == 0)
18777             break;
18778           error (_("%s: failed to read archive header\n"), filedata->file_name);
18779           ret = FALSE;
18780           break;
18781         }
18782       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
18783         {
18784           error (_("%s: did not find a valid archive header\n"), arch.file_name);
18785           ret = FALSE;
18786           break;
18787         }
18788
18789       arch.next_arhdr_offset += sizeof arch.arhdr;
18790
18791       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
18792       if (archive_file_size & 01)
18793         ++archive_file_size;
18794
18795       name = get_archive_member_name (&arch, &nested_arch);
18796       if (name == NULL)
18797         {
18798           error (_("%s: bad archive file name\n"), filedata->file_name);
18799           ret = FALSE;
18800           break;
18801         }
18802       namelen = strlen (name);
18803
18804       qualified_name = make_qualified_name (&arch, &nested_arch, name);
18805       if (qualified_name == NULL)
18806         {
18807           error (_("%s: bad archive file name\n"), filedata->file_name);
18808           ret = FALSE;
18809           break;
18810         }
18811
18812       if (is_thin_archive && arch.nested_member_origin == 0)
18813         {
18814           /* This is a proxy for an external member of a thin archive.  */
18815           Filedata * member_filedata;
18816           char * member_file_name = adjust_relative_path
18817             (filedata->file_name, name, namelen);
18818
18819           if (member_file_name == NULL)
18820             {
18821               ret = FALSE;
18822               break;
18823             }
18824
18825           member_filedata = open_file (member_file_name);
18826           if (member_filedata == NULL)
18827             {
18828               error (_("Input file '%s' is not readable.\n"), member_file_name);
18829               free (member_file_name);
18830               ret = FALSE;
18831               break;
18832             }
18833
18834           archive_file_offset = arch.nested_member_origin;
18835           member_filedata->file_name = qualified_name;
18836
18837           if (! process_object (member_filedata))
18838             ret = FALSE;
18839
18840           close_file (member_filedata);
18841           free (member_file_name);
18842         }
18843       else if (is_thin_archive)
18844         {
18845           Filedata thin_filedata = { 0 };
18846
18847           /* PR 15140: Allow for corrupt thin archives.  */
18848           if (nested_arch.file == NULL)
18849             {
18850               error (_("%s: contains corrupt thin archive: %s\n"),
18851                      filedata->file_name, name);
18852               ret = FALSE;
18853               break;
18854             }
18855
18856           /* This is a proxy for a member of a nested archive.  */
18857           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
18858
18859           /* The nested archive file will have been opened and setup by
18860              get_archive_member_name.  */
18861           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
18862             {
18863               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
18864               ret = FALSE;
18865               break;
18866             }
18867
18868           thin_filedata.handle = nested_arch.file;
18869           thin_filedata.file_name = qualified_name;
18870
18871           if (! process_object (& thin_filedata))
18872             ret = FALSE;
18873         }
18874       else
18875         {
18876           archive_file_offset = arch.next_arhdr_offset;
18877           arch.next_arhdr_offset += archive_file_size;
18878
18879           filedata->file_name = qualified_name;
18880           if (! process_object (filedata))
18881             ret = FALSE;
18882         }
18883
18884       if (filedata->dump_sects != NULL)
18885         {
18886           free (filedata->dump_sects);
18887           filedata->dump_sects = NULL;
18888           filedata->num_dump_sects = 0;
18889         }
18890
18891       free (qualified_name);
18892     }
18893
18894  out:
18895   if (nested_arch.file != NULL)
18896     fclose (nested_arch.file);
18897   release_archive (&nested_arch);
18898   release_archive (&arch);
18899
18900   return ret;
18901 }
18902
18903 static bfd_boolean
18904 process_file (char * file_name)
18905 {
18906   Filedata * filedata = NULL;
18907   struct stat statbuf;
18908   char armag[SARMAG];
18909   bfd_boolean ret = TRUE;
18910
18911   if (stat (file_name, &statbuf) < 0)
18912     {
18913       if (errno == ENOENT)
18914         error (_("'%s': No such file\n"), file_name);
18915       else
18916         error (_("Could not locate '%s'.  System error message: %s\n"),
18917                file_name, strerror (errno));
18918       return FALSE;
18919     }
18920
18921   if (! S_ISREG (statbuf.st_mode))
18922     {
18923       error (_("'%s' is not an ordinary file\n"), file_name);
18924       return FALSE;
18925     }
18926
18927   filedata = calloc (1, sizeof * filedata);
18928   if (filedata == NULL)
18929     {
18930       error (_("Out of memory allocating file data structure\n"));
18931       return FALSE;
18932     }
18933
18934   filedata->file_name = file_name;
18935   filedata->handle = fopen (file_name, "rb");
18936   if (filedata->handle == NULL)
18937     {
18938       error (_("Input file '%s' is not readable.\n"), file_name);
18939       free (filedata);
18940       return FALSE;
18941     }
18942
18943   if (fread (armag, SARMAG, 1, filedata->handle) != 1)
18944     {
18945       error (_("%s: Failed to read file's magic number\n"), file_name);
18946       fclose (filedata->handle);
18947       free (filedata);
18948       return FALSE;
18949     }
18950
18951   filedata->file_size = (bfd_size_type) statbuf.st_size;
18952
18953   if (memcmp (armag, ARMAG, SARMAG) == 0)
18954     {
18955       if (! process_archive (filedata, FALSE))
18956         ret = FALSE;
18957     }
18958   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
18959     {
18960       if ( ! process_archive (filedata, TRUE))
18961         ret = FALSE;
18962     }
18963   else
18964     {
18965       if (do_archive_index)
18966         error (_("File %s is not an archive so its index cannot be displayed.\n"),
18967                file_name);
18968
18969       rewind (filedata->handle);
18970       archive_file_size = archive_file_offset = 0;
18971
18972       if (! process_object (filedata))
18973         ret = FALSE;
18974     }
18975
18976   fclose (filedata->handle);
18977   free (filedata);
18978
18979   return ret;
18980 }
18981
18982 #ifdef SUPPORT_DISASSEMBLY
18983 /* Needed by the i386 disassembler.  For extra credit, someone could
18984    fix this so that we insert symbolic addresses here, esp for GOT/PLT
18985    symbols.  */
18986
18987 void
18988 print_address (unsigned int addr, FILE * outfile)
18989 {
18990   fprintf (outfile,"0x%8.8x", addr);
18991 }
18992
18993 /* Needed by the i386 disassembler.  */
18994
18995 void
18996 db_task_printsym (unsigned int addr)
18997 {
18998   print_address (addr, stderr);
18999 }
19000 #endif
19001
19002 int
19003 main (int argc, char ** argv)
19004 {
19005   int err;
19006
19007 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19008   setlocale (LC_MESSAGES, "");
19009 #endif
19010 #if defined (HAVE_SETLOCALE)
19011   setlocale (LC_CTYPE, "");
19012 #endif
19013   bindtextdomain (PACKAGE, LOCALEDIR);
19014   textdomain (PACKAGE);
19015
19016   expandargv (&argc, &argv);
19017
19018   cmdline.file_name = "<cmdline>";
19019   parse_args (& cmdline, argc, argv);
19020
19021   if (optind < (argc - 1))
19022     show_name = TRUE;
19023   else if (optind >= argc)
19024     {
19025       warn (_("Nothing to do.\n"));
19026       usage (stderr);
19027     }
19028
19029   err = FALSE;
19030   while (optind < argc)
19031     if (! process_file (argv[optind++]))
19032       err = TRUE;
19033
19034   if (cmdline.dump_sects != NULL)
19035     free (cmdline.dump_sects);
19036
19037   return err ? EXIT_FAILURE : EXIT_SUCCESS;
19038 }