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 || do_debug_links)
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   /* Without section headers we cannot find any sections.  */
13578   if (filedata->section_headers == NULL)
13579     return FALSE;
13580
13581   if (filedata->string_table == NULL)
13582     {
13583       Elf_Internal_Shdr * strs;
13584
13585       /* Read in the string table, so that we have section names to scan.  */
13586       strs = filedata->section_headers + filedata->file_header.e_shstrndx;
13587
13588       if (strs != NULL && strs->sh_size != 0)
13589         {
13590           filedata->string_table = (char *) get_data (NULL, filedata, strs->sh_offset,
13591                                                       1, strs->sh_size,
13592                                                       _("string table"));
13593
13594           filedata->string_table_length = filedata->string_table != NULL ? strs->sh_size : 0;
13595         }
13596     }
13597
13598   /* Locate the debug section.  */
13599   sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
13600   if (sec != NULL)
13601     section->name = section->uncompressed_name;
13602   else
13603     {
13604       sec = find_section_in_set (filedata, section->compressed_name, section_subset);
13605       if (sec != NULL)
13606         section->name = section->compressed_name;
13607     }
13608   if (sec == NULL)
13609     return FALSE;
13610
13611   /* If we're loading from a subset of sections, and we've loaded
13612      a section matching this name before, it's likely that it's a
13613      different one.  */
13614   if (section_subset != NULL)
13615     free_debug_section (debug);
13616
13617   return load_specific_debug_section (debug, sec, data);
13618 }
13619
13620 void
13621 free_debug_section (enum dwarf_section_display_enum debug)
13622 {
13623   struct dwarf_section * section = &debug_displays [debug].section;
13624
13625   if (section->start == NULL)
13626     return;
13627
13628   free ((char *) section->start);
13629   section->start = NULL;
13630   section->address = 0;
13631   section->size = 0;
13632 }
13633
13634 static bfd_boolean
13635 display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
13636 {
13637   char * name = SECTION_NAME (section);
13638   const char * print_name = printable_section_name (filedata, section);
13639   bfd_size_type length;
13640   bfd_boolean result = TRUE;
13641   int i;
13642
13643   length = section->sh_size;
13644   if (length == 0)
13645     {
13646       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13647       return TRUE;
13648     }
13649   if (section->sh_type == SHT_NOBITS)
13650     {
13651       /* There is no point in dumping the contents of a debugging section
13652          which has the NOBITS type - the bits in the file will be random.
13653          This can happen when a file containing a .eh_frame section is
13654          stripped with the --only-keep-debug command line option.  */
13655       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13656               print_name);
13657       return FALSE;
13658     }
13659
13660   if (const_strneq (name, ".gnu.linkonce.wi."))
13661     name = ".debug_info";
13662
13663   /* See if we know how to display the contents of this section.  */
13664   for (i = 0; i < max; i++)
13665     {
13666       enum dwarf_section_display_enum  id = (enum dwarf_section_display_enum) i;
13667       struct dwarf_section_display *   display = debug_displays + i;
13668       struct dwarf_section *           sec = & display->section;
13669
13670       if (streq (sec->uncompressed_name, name)
13671           || (id == line && const_strneq (name, ".debug_line."))
13672           || streq (sec->compressed_name, name))
13673         {
13674           bfd_boolean secondary = (section != find_section (filedata, name));
13675
13676           if (secondary)
13677             free_debug_section (id);
13678
13679           if (i == line && const_strneq (name, ".debug_line."))
13680             sec->name = name;
13681           else if (streq (sec->uncompressed_name, name))
13682             sec->name = sec->uncompressed_name;
13683           else
13684             sec->name = sec->compressed_name;
13685
13686           if (load_specific_debug_section (id, section, filedata))
13687             {
13688               /* If this debug section is part of a CU/TU set in a .dwp file,
13689                  restrict load_debug_section to the sections in that set.  */
13690               section_subset = find_cu_tu_set (filedata, shndx);
13691
13692               result &= display->display (sec, filedata);
13693
13694               section_subset = NULL;
13695
13696               if (secondary || (id != info && id != abbrev))
13697                 free_debug_section (id);
13698             }
13699           break;
13700         }
13701     }
13702
13703   if (i == max)
13704     {
13705       printf (_("Unrecognized debug section: %s\n"), print_name);
13706       result = FALSE;
13707     }
13708
13709   return result;
13710 }
13711
13712 /* Set DUMP_SECTS for all sections where dumps were requested
13713    based on section name.  */
13714
13715 static void
13716 initialise_dumps_byname (Filedata * filedata)
13717 {
13718   struct dump_list_entry * cur;
13719
13720   for (cur = dump_sects_byname; cur; cur = cur->next)
13721     {
13722       unsigned int i;
13723       bfd_boolean any = FALSE;
13724
13725       for (i = 0; i < filedata->file_header.e_shnum; i++)
13726         if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
13727           {
13728             request_dump_bynumber (filedata, i, cur->type);
13729             any = TRUE;
13730           }
13731
13732       if (!any)
13733         warn (_("Section '%s' was not dumped because it does not exist!\n"),
13734               cur->name);
13735     }
13736 }
13737
13738 static bfd_boolean
13739 process_section_contents (Filedata * filedata)
13740 {
13741   Elf_Internal_Shdr * section;
13742   unsigned int i;
13743   bfd_boolean res = TRUE;
13744
13745   if (! do_dump)
13746     return TRUE;
13747
13748   initialise_dumps_byname (filedata);
13749
13750   for (i = 0, section = filedata->section_headers;
13751        i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
13752        i++, section++)
13753     {
13754       dump_type dump = filedata->dump_sects[i];
13755
13756 #ifdef SUPPORT_DISASSEMBLY
13757       if (dump & DISASS_DUMP)
13758         {
13759           if (! disassemble_section (section, filedata))
13760             res = FALSE;
13761         }
13762 #endif
13763       if (dump & HEX_DUMP)
13764         {
13765           if (! dump_section_as_bytes (section, filedata, FALSE))
13766             res = FALSE;
13767         }
13768
13769       if (dump & RELOC_DUMP)
13770         {
13771           if (! dump_section_as_bytes (section, filedata, TRUE))
13772             res = FALSE;
13773         }
13774
13775       if (dump & STRING_DUMP)
13776         {
13777           if (! dump_section_as_strings (section, filedata))
13778             res = FALSE;
13779         }
13780
13781       if (dump & DEBUG_DUMP)
13782         {
13783           if (! display_debug_section (i, section, filedata))
13784             res = FALSE;
13785         }
13786     }
13787
13788   /* Check to see if the user requested a
13789      dump of a section that does not exist.  */
13790   while (i < filedata->num_dump_sects)
13791     {
13792       if (filedata->dump_sects[i])
13793         {
13794           warn (_("Section %d was not dumped because it does not exist!\n"), i);
13795           res = FALSE;
13796         }
13797       i++;
13798     }
13799
13800   return res;
13801 }
13802
13803 static void
13804 process_mips_fpe_exception (int mask)
13805 {
13806   if (mask)
13807     {
13808       bfd_boolean first = TRUE;
13809
13810       if (mask & OEX_FPU_INEX)
13811         fputs ("INEX", stdout), first = FALSE;
13812       if (mask & OEX_FPU_UFLO)
13813         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
13814       if (mask & OEX_FPU_OFLO)
13815         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
13816       if (mask & OEX_FPU_DIV0)
13817         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
13818       if (mask & OEX_FPU_INVAL)
13819         printf ("%sINVAL", first ? "" : "|");
13820     }
13821   else
13822     fputs ("0", stdout);
13823 }
13824
13825 /* Display's the value of TAG at location P.  If TAG is
13826    greater than 0 it is assumed to be an unknown tag, and
13827    a message is printed to this effect.  Otherwise it is
13828    assumed that a message has already been printed.
13829
13830    If the bottom bit of TAG is set it assumed to have a
13831    string value, otherwise it is assumed to have an integer
13832    value.
13833
13834    Returns an updated P pointing to the first unread byte
13835    beyond the end of TAG's value.
13836
13837    Reads at or beyond END will not be made.  */
13838
13839 static unsigned char *
13840 display_tag_value (signed int tag,
13841                    unsigned char * p,
13842                    const unsigned char * const end)
13843 {
13844   unsigned long val;
13845
13846   if (tag > 0)
13847     printf ("  Tag_unknown_%d: ", tag);
13848
13849   if (p >= end)
13850     {
13851       warn (_("<corrupt tag>\n"));
13852     }
13853   else if (tag & 1)
13854     {
13855       /* PR 17531 file: 027-19978-0.004.  */
13856       size_t maxlen = (end - p) - 1;
13857
13858       putchar ('"');
13859       if (maxlen > 0)
13860         {
13861           print_symbol ((int) maxlen, (const char *) p);
13862           p += strnlen ((char *) p, maxlen) + 1;
13863         }
13864       else
13865         {
13866           printf (_("<corrupt string tag>"));
13867           p = (unsigned char *) end;
13868         }
13869       printf ("\"\n");
13870     }
13871   else
13872     {
13873       unsigned int len;
13874
13875       val = read_uleb128 (p, &len, end);
13876       p += len;
13877       printf ("%ld (0x%lx)\n", val, val);
13878     }
13879
13880   assert (p <= end);
13881   return p;
13882 }
13883
13884 /* ARC ABI attributes section.  */
13885
13886 static unsigned char *
13887 display_arc_attribute (unsigned char * p,
13888                        const unsigned char * const end)
13889 {
13890   unsigned int tag;
13891   unsigned int len;
13892   unsigned int val;
13893
13894   tag = read_uleb128 (p, &len, end);
13895   p += len;
13896
13897   switch (tag)
13898     {
13899     case Tag_ARC_PCS_config:
13900       val = read_uleb128 (p, &len, end);
13901       p += len;
13902       printf ("  Tag_ARC_PCS_config: ");
13903       switch (val)
13904         {
13905         case 0:
13906           printf (_("Absent/Non standard\n"));
13907           break;
13908         case 1:
13909           printf (_("Bare metal/mwdt\n"));
13910           break;
13911         case 2:
13912           printf (_("Bare metal/newlib\n"));
13913           break;
13914         case 3:
13915           printf (_("Linux/uclibc\n"));
13916           break;
13917         case 4:
13918           printf (_("Linux/glibc\n"));
13919           break;
13920         default:
13921           printf (_("Unknown\n"));
13922           break;
13923         }
13924       break;
13925
13926     case Tag_ARC_CPU_base:
13927       val = read_uleb128 (p, &len, end);
13928       p += len;
13929       printf ("  Tag_ARC_CPU_base: ");
13930       switch (val)
13931         {
13932         default:
13933         case TAG_CPU_NONE:
13934           printf (_("Absent\n"));
13935           break;
13936         case TAG_CPU_ARC6xx:
13937           printf ("ARC6xx\n");
13938           break;
13939         case TAG_CPU_ARC7xx:
13940           printf ("ARC7xx\n");
13941           break;
13942         case TAG_CPU_ARCEM:
13943           printf ("ARCEM\n");
13944           break;
13945         case TAG_CPU_ARCHS:
13946           printf ("ARCHS\n");
13947           break;
13948         }
13949       break;
13950
13951     case Tag_ARC_CPU_variation:
13952       val = read_uleb128 (p, &len, end);
13953       p += len;
13954       printf ("  Tag_ARC_CPU_variation: ");
13955       switch (val)
13956         {
13957         default:
13958           if (val > 0 && val < 16)
13959               printf ("Core%d\n", val);
13960           else
13961               printf ("Unknown\n");
13962           break;
13963
13964         case 0:
13965           printf (_("Absent\n"));
13966           break;
13967         }
13968       break;
13969
13970     case Tag_ARC_CPU_name:
13971       printf ("  Tag_ARC_CPU_name: ");
13972       p = display_tag_value (-1, p, end);
13973       break;
13974
13975     case Tag_ARC_ABI_rf16:
13976       val = read_uleb128 (p, &len, end);
13977       p += len;
13978       printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
13979       break;
13980
13981     case Tag_ARC_ABI_osver:
13982       val = read_uleb128 (p, &len, end);
13983       p += len;
13984       printf ("  Tag_ARC_ABI_osver: v%d\n", val);
13985       break;
13986
13987     case Tag_ARC_ABI_pic:
13988     case Tag_ARC_ABI_sda:
13989       val = read_uleb128 (p, &len, end);
13990       p += len;
13991       printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
13992               : "  Tag_ARC_ABI_pic: ");
13993       switch (val)
13994         {
13995         case 0:
13996           printf (_("Absent\n"));
13997           break;
13998         case 1:
13999           printf ("MWDT\n");
14000           break;
14001         case 2:
14002           printf ("GNU\n");
14003           break;
14004         default:
14005           printf (_("Unknown\n"));
14006           break;
14007         }
14008       break;
14009
14010     case Tag_ARC_ABI_tls:
14011       val = read_uleb128 (p, &len, end);
14012       p += len;
14013       printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14014       break;
14015
14016     case Tag_ARC_ABI_enumsize:
14017       val = read_uleb128 (p, &len, end);
14018       p += len;
14019       printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14020               _("smallest"));
14021       break;
14022
14023     case Tag_ARC_ABI_exceptions:
14024       val = read_uleb128 (p, &len, end);
14025       p += len;
14026       printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14027               : _("default"));
14028       break;
14029
14030     case Tag_ARC_ABI_double_size:
14031       val = read_uleb128 (p, &len, end);
14032       p += len;
14033       printf ("  Tag_ARC_ABI_double_size: %d\n", val);
14034       break;
14035
14036     case Tag_ARC_ISA_config:
14037       printf ("  Tag_ARC_ISA_config: ");
14038       p = display_tag_value (-1, p, end);
14039       break;
14040
14041     case Tag_ARC_ISA_apex:
14042       printf ("  Tag_ARC_ISA_apex: ");
14043       p = display_tag_value (-1, p, end);
14044       break;
14045
14046     case Tag_ARC_ISA_mpy_option:
14047       val = read_uleb128 (p, &len, end);
14048       p += len;
14049       printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
14050       break;
14051
14052     default:
14053       return display_tag_value (tag & 1, p, end);
14054     }
14055
14056   return p;
14057 }
14058
14059 /* ARM EABI attributes section.  */
14060 typedef struct
14061 {
14062   unsigned int tag;
14063   const char * name;
14064   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
14065   unsigned int type;
14066   const char ** table;
14067 } arm_attr_public_tag;
14068
14069 static const char * arm_attr_tag_CPU_arch[] =
14070   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14071    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14072    "v8-M.mainline"};
14073 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14074 static const char * arm_attr_tag_THUMB_ISA_use[] =
14075   {"No", "Thumb-1", "Thumb-2", "Yes"};
14076 static const char * arm_attr_tag_FP_arch[] =
14077   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14078    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14079 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14080 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14081   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14082    "NEON for ARMv8.1"};
14083 static const char * arm_attr_tag_PCS_config[] =
14084   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14085    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14086 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14087   {"V6", "SB", "TLS", "Unused"};
14088 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14089   {"Absolute", "PC-relative", "SB-relative", "None"};
14090 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14091   {"Absolute", "PC-relative", "None"};
14092 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14093   {"None", "direct", "GOT-indirect"};
14094 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14095   {"None", "??? 1", "2", "??? 3", "4"};
14096 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14097 static const char * arm_attr_tag_ABI_FP_denormal[] =
14098   {"Unused", "Needed", "Sign only"};
14099 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14100 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14101 static const char * arm_attr_tag_ABI_FP_number_model[] =
14102   {"Unused", "Finite", "RTABI", "IEEE 754"};
14103 static const char * arm_attr_tag_ABI_enum_size[] =
14104   {"Unused", "small", "int", "forced to int"};
14105 static const char * arm_attr_tag_ABI_HardFP_use[] =
14106   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14107 static const char * arm_attr_tag_ABI_VFP_args[] =
14108   {"AAPCS", "VFP registers", "custom", "compatible"};
14109 static const char * arm_attr_tag_ABI_WMMX_args[] =
14110   {"AAPCS", "WMMX registers", "custom"};
14111 static const char * arm_attr_tag_ABI_optimization_goals[] =
14112   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14113     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14114 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14115   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14116     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14117 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14118 static const char * arm_attr_tag_FP_HP_extension[] =
14119   {"Not Allowed", "Allowed"};
14120 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14121   {"None", "IEEE 754", "Alternative Format"};
14122 static const char * arm_attr_tag_DSP_extension[] =
14123   {"Follow architecture", "Allowed"};
14124 static const char * arm_attr_tag_MPextension_use[] =
14125   {"Not Allowed", "Allowed"};
14126 static const char * arm_attr_tag_DIV_use[] =
14127   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14128     "Allowed in v7-A with integer division extension"};
14129 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14130 static const char * arm_attr_tag_Virtualization_use[] =
14131   {"Not Allowed", "TrustZone", "Virtualization Extensions",
14132     "TrustZone and Virtualization Extensions"};
14133 static const char * arm_attr_tag_MPextension_use_legacy[] =
14134   {"Not Allowed", "Allowed"};
14135
14136 #define LOOKUP(id, name) \
14137   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14138 static arm_attr_public_tag arm_attr_public_tags[] =
14139 {
14140   {4, "CPU_raw_name", 1, NULL},
14141   {5, "CPU_name", 1, NULL},
14142   LOOKUP(6, CPU_arch),
14143   {7, "CPU_arch_profile", 0, NULL},
14144   LOOKUP(8, ARM_ISA_use),
14145   LOOKUP(9, THUMB_ISA_use),
14146   LOOKUP(10, FP_arch),
14147   LOOKUP(11, WMMX_arch),
14148   LOOKUP(12, Advanced_SIMD_arch),
14149   LOOKUP(13, PCS_config),
14150   LOOKUP(14, ABI_PCS_R9_use),
14151   LOOKUP(15, ABI_PCS_RW_data),
14152   LOOKUP(16, ABI_PCS_RO_data),
14153   LOOKUP(17, ABI_PCS_GOT_use),
14154   LOOKUP(18, ABI_PCS_wchar_t),
14155   LOOKUP(19, ABI_FP_rounding),
14156   LOOKUP(20, ABI_FP_denormal),
14157   LOOKUP(21, ABI_FP_exceptions),
14158   LOOKUP(22, ABI_FP_user_exceptions),
14159   LOOKUP(23, ABI_FP_number_model),
14160   {24, "ABI_align_needed", 0, NULL},
14161   {25, "ABI_align_preserved", 0, NULL},
14162   LOOKUP(26, ABI_enum_size),
14163   LOOKUP(27, ABI_HardFP_use),
14164   LOOKUP(28, ABI_VFP_args),
14165   LOOKUP(29, ABI_WMMX_args),
14166   LOOKUP(30, ABI_optimization_goals),
14167   LOOKUP(31, ABI_FP_optimization_goals),
14168   {32, "compatibility", 0, NULL},
14169   LOOKUP(34, CPU_unaligned_access),
14170   LOOKUP(36, FP_HP_extension),
14171   LOOKUP(38, ABI_FP_16bit_format),
14172   LOOKUP(42, MPextension_use),
14173   LOOKUP(44, DIV_use),
14174   LOOKUP(46, DSP_extension),
14175   {64, "nodefaults", 0, NULL},
14176   {65, "also_compatible_with", 0, NULL},
14177   LOOKUP(66, T2EE_use),
14178   {67, "conformance", 1, NULL},
14179   LOOKUP(68, Virtualization_use),
14180   LOOKUP(70, MPextension_use_legacy)
14181 };
14182 #undef LOOKUP
14183
14184 static unsigned char *
14185 display_arm_attribute (unsigned char * p,
14186                        const unsigned char * const end)
14187 {
14188   unsigned int tag;
14189   unsigned int len;
14190   unsigned int val;
14191   arm_attr_public_tag * attr;
14192   unsigned i;
14193   unsigned int type;
14194
14195   tag = read_uleb128 (p, &len, end);
14196   p += len;
14197   attr = NULL;
14198   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14199     {
14200       if (arm_attr_public_tags[i].tag == tag)
14201         {
14202           attr = &arm_attr_public_tags[i];
14203           break;
14204         }
14205     }
14206
14207   if (attr)
14208     {
14209       printf ("  Tag_%s: ", attr->name);
14210       switch (attr->type)
14211         {
14212         case 0:
14213           switch (tag)
14214             {
14215             case 7: /* Tag_CPU_arch_profile.  */
14216               val = read_uleb128 (p, &len, end);
14217               p += len;
14218               switch (val)
14219                 {
14220                 case 0: printf (_("None\n")); break;
14221                 case 'A': printf (_("Application\n")); break;
14222                 case 'R': printf (_("Realtime\n")); break;
14223                 case 'M': printf (_("Microcontroller\n")); break;
14224                 case 'S': printf (_("Application or Realtime\n")); break;
14225                 default: printf ("??? (%d)\n", val); break;
14226                 }
14227               break;
14228
14229             case 24: /* Tag_align_needed.  */
14230               val = read_uleb128 (p, &len, end);
14231               p += len;
14232               switch (val)
14233                 {
14234                 case 0: printf (_("None\n")); break;
14235                 case 1: printf (_("8-byte\n")); break;
14236                 case 2: printf (_("4-byte\n")); break;
14237                 case 3: printf ("??? 3\n"); break;
14238                 default:
14239                   if (val <= 12)
14240                     printf (_("8-byte and up to %d-byte extended\n"),
14241                             1 << val);
14242                   else
14243                     printf ("??? (%d)\n", val);
14244                   break;
14245                 }
14246               break;
14247
14248             case 25: /* Tag_align_preserved.  */
14249               val = read_uleb128 (p, &len, end);
14250               p += len;
14251               switch (val)
14252                 {
14253                 case 0: printf (_("None\n")); break;
14254                 case 1: printf (_("8-byte, except leaf SP\n")); break;
14255                 case 2: printf (_("8-byte\n")); break;
14256                 case 3: printf ("??? 3\n"); break;
14257                 default:
14258                   if (val <= 12)
14259                     printf (_("8-byte and up to %d-byte extended\n"),
14260                             1 << val);
14261                   else
14262                     printf ("??? (%d)\n", val);
14263                   break;
14264                 }
14265               break;
14266
14267             case 32: /* Tag_compatibility.  */
14268               {
14269                 val = read_uleb128 (p, &len, end);
14270                 p += len;
14271                 printf (_("flag = %d, vendor = "), val);
14272                 if (p < end - 1)
14273                   {
14274                     size_t maxlen = (end - p) - 1;
14275
14276                     print_symbol ((int) maxlen, (const char *) p);
14277                     p += strnlen ((char *) p, maxlen) + 1;
14278                   }
14279                 else
14280                   {
14281                     printf (_("<corrupt>"));
14282                     p = (unsigned char *) end;
14283                   }
14284                 putchar ('\n');
14285               }
14286               break;
14287
14288             case 64: /* Tag_nodefaults.  */
14289               /* PR 17531: file: 001-505008-0.01.  */
14290               if (p < end)
14291                 p++;
14292               printf (_("True\n"));
14293               break;
14294
14295             case 65: /* Tag_also_compatible_with.  */
14296               val = read_uleb128 (p, &len, end);
14297               p += len;
14298               if (val == 6 /* Tag_CPU_arch.  */)
14299                 {
14300                   val = read_uleb128 (p, &len, end);
14301                   p += len;
14302                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14303                     printf ("??? (%d)\n", val);
14304                   else
14305                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14306                 }
14307               else
14308                 printf ("???\n");
14309               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
14310                 ;
14311               break;
14312
14313             default:
14314               printf (_("<unknown: %d>\n"), tag);
14315               break;
14316             }
14317           return p;
14318
14319         case 1:
14320           return display_tag_value (-1, p, end);
14321         case 2:
14322           return display_tag_value (0, p, end);
14323
14324         default:
14325           assert (attr->type & 0x80);
14326           val = read_uleb128 (p, &len, end);
14327           p += len;
14328           type = attr->type & 0x7f;
14329           if (val >= type)
14330             printf ("??? (%d)\n", val);
14331           else
14332             printf ("%s\n", attr->table[val]);
14333           return p;
14334         }
14335     }
14336
14337   return display_tag_value (tag, p, end);
14338 }
14339
14340 static unsigned char *
14341 display_gnu_attribute (unsigned char * p,
14342                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14343                        const unsigned char * const end)
14344 {
14345   int tag;
14346   unsigned int len;
14347   unsigned int val;
14348
14349   tag = read_uleb128 (p, &len, end);
14350   p += len;
14351
14352   /* Tag_compatibility is the only generic GNU attribute defined at
14353      present.  */
14354   if (tag == 32)
14355     {
14356       val = read_uleb128 (p, &len, end);
14357       p += len;
14358
14359       printf (_("flag = %d, vendor = "), val);
14360       if (p == end)
14361         {
14362           printf (_("<corrupt>\n"));
14363           warn (_("corrupt vendor attribute\n"));
14364         }
14365       else
14366         {
14367           if (p < end - 1)
14368             {
14369               size_t maxlen = (end - p) - 1;
14370
14371               print_symbol ((int) maxlen, (const char *) p);
14372               p += strnlen ((char *) p, maxlen) + 1;
14373             }
14374           else
14375             {
14376               printf (_("<corrupt>"));
14377               p = (unsigned char *) end;
14378             }
14379           putchar ('\n');
14380         }
14381       return p;
14382     }
14383
14384   if ((tag & 2) == 0 && display_proc_gnu_attribute)
14385     return display_proc_gnu_attribute (p, tag, end);
14386
14387   return display_tag_value (tag, p, end);
14388 }
14389
14390 static unsigned char *
14391 display_power_gnu_attribute (unsigned char * p,
14392                              unsigned int tag,
14393                              const unsigned char * const end)
14394 {
14395   unsigned int len;
14396   unsigned int val;
14397
14398   if (tag == Tag_GNU_Power_ABI_FP)
14399     {
14400       val = read_uleb128 (p, &len, end);
14401       p += len;
14402       printf ("  Tag_GNU_Power_ABI_FP: ");
14403       if (len == 0)
14404         {
14405           printf (_("<corrupt>\n"));
14406           return p;
14407         }
14408
14409       if (val > 15)
14410         printf ("(%#x), ", val);
14411
14412       switch (val & 3)
14413         {
14414         case 0:
14415           printf (_("unspecified hard/soft float, "));
14416           break;
14417         case 1:
14418           printf (_("hard float, "));
14419           break;
14420         case 2:
14421           printf (_("soft float, "));
14422           break;
14423         case 3:
14424           printf (_("single-precision hard float, "));
14425           break;
14426         }
14427
14428       switch (val & 0xC)
14429         {
14430         case 0:
14431           printf (_("unspecified long double\n"));
14432           break;
14433         case 4:
14434           printf (_("128-bit IBM long double\n"));
14435           break;
14436         case 8:
14437           printf (_("64-bit long double\n"));
14438           break;
14439         case 12:
14440           printf (_("128-bit IEEE long double\n"));
14441           break;
14442         }
14443       return p;
14444     }
14445
14446   if (tag == Tag_GNU_Power_ABI_Vector)
14447     {
14448       val = read_uleb128 (p, &len, end);
14449       p += len;
14450       printf ("  Tag_GNU_Power_ABI_Vector: ");
14451       if (len == 0)
14452         {
14453           printf (_("<corrupt>\n"));
14454           return p;
14455         }
14456
14457       if (val > 3)
14458         printf ("(%#x), ", val);
14459
14460       switch (val & 3)
14461         {
14462         case 0:
14463           printf (_("unspecified\n"));
14464           break;
14465         case 1:
14466           printf (_("generic\n"));
14467           break;
14468         case 2:
14469           printf ("AltiVec\n");
14470           break;
14471         case 3:
14472           printf ("SPE\n");
14473           break;
14474         }
14475       return p;
14476     }
14477
14478   if (tag == Tag_GNU_Power_ABI_Struct_Return)
14479     {
14480       val = read_uleb128 (p, &len, end);
14481       p += len;
14482       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
14483       if (len == 0)
14484         {
14485           printf (_("<corrupt>\n"));
14486           return p;
14487         }
14488
14489       if (val > 2)
14490         printf ("(%#x), ", val);
14491
14492       switch (val & 3)
14493         {
14494         case 0:
14495           printf (_("unspecified\n"));
14496           break;
14497         case 1:
14498           printf ("r3/r4\n");
14499           break;
14500         case 2:
14501           printf (_("memory\n"));
14502           break;
14503         case 3:
14504           printf ("???\n");
14505           break;
14506         }
14507       return p;
14508     }
14509
14510   return display_tag_value (tag & 1, p, end);
14511 }
14512
14513 static unsigned char *
14514 display_s390_gnu_attribute (unsigned char * p,
14515                             unsigned int tag,
14516                             const unsigned char * const end)
14517 {
14518   unsigned int len;
14519   int val;
14520
14521   if (tag == Tag_GNU_S390_ABI_Vector)
14522     {
14523       val = read_uleb128 (p, &len, end);
14524       p += len;
14525       printf ("  Tag_GNU_S390_ABI_Vector: ");
14526
14527       switch (val)
14528         {
14529         case 0:
14530           printf (_("any\n"));
14531           break;
14532         case 1:
14533           printf (_("software\n"));
14534           break;
14535         case 2:
14536           printf (_("hardware\n"));
14537           break;
14538         default:
14539           printf ("??? (%d)\n", val);
14540           break;
14541         }
14542       return p;
14543    }
14544
14545   return display_tag_value (tag & 1, p, end);
14546 }
14547
14548 static void
14549 display_sparc_hwcaps (unsigned int mask)
14550 {
14551   if (mask)
14552     {
14553       bfd_boolean first = TRUE;
14554
14555       if (mask & ELF_SPARC_HWCAP_MUL32)
14556         fputs ("mul32", stdout), first = FALSE;
14557       if (mask & ELF_SPARC_HWCAP_DIV32)
14558         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14559       if (mask & ELF_SPARC_HWCAP_FSMULD)
14560         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14561       if (mask & ELF_SPARC_HWCAP_V8PLUS)
14562         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14563       if (mask & ELF_SPARC_HWCAP_POPC)
14564         printf ("%spopc", first ? "" : "|"), first = FALSE;
14565       if (mask & ELF_SPARC_HWCAP_VIS)
14566         printf ("%svis", first ? "" : "|"), first = FALSE;
14567       if (mask & ELF_SPARC_HWCAP_VIS2)
14568         printf ("%svis2", first ? "" : "|"), first = FALSE;
14569       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14570         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14571       if (mask & ELF_SPARC_HWCAP_FMAF)
14572         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14573       if (mask & ELF_SPARC_HWCAP_VIS3)
14574         printf ("%svis3", first ? "" : "|"), first = FALSE;
14575       if (mask & ELF_SPARC_HWCAP_HPC)
14576         printf ("%shpc", first ? "" : "|"), first = FALSE;
14577       if (mask & ELF_SPARC_HWCAP_RANDOM)
14578         printf ("%srandom", first ? "" : "|"), first = FALSE;
14579       if (mask & ELF_SPARC_HWCAP_TRANS)
14580         printf ("%strans", first ? "" : "|"), first = FALSE;
14581       if (mask & ELF_SPARC_HWCAP_FJFMAU)
14582         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14583       if (mask & ELF_SPARC_HWCAP_IMA)
14584         printf ("%sima", first ? "" : "|"), first = FALSE;
14585       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14586         printf ("%scspare", first ? "" : "|"), first = FALSE;
14587     }
14588   else
14589     fputc ('0', stdout);
14590   fputc ('\n', stdout);
14591 }
14592
14593 static void
14594 display_sparc_hwcaps2 (unsigned int mask)
14595 {
14596   if (mask)
14597     {
14598       bfd_boolean first = TRUE;
14599
14600       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14601         fputs ("fjathplus", stdout), first = FALSE;
14602       if (mask & ELF_SPARC_HWCAP2_VIS3B)
14603         printf ("%svis3b", first ? "" : "|"), first = FALSE;
14604       if (mask & ELF_SPARC_HWCAP2_ADP)
14605         printf ("%sadp", first ? "" : "|"), first = FALSE;
14606       if (mask & ELF_SPARC_HWCAP2_SPARC5)
14607         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14608       if (mask & ELF_SPARC_HWCAP2_MWAIT)
14609         printf ("%smwait", first ? "" : "|"), first = FALSE;
14610       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14611         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14612       if (mask & ELF_SPARC_HWCAP2_XMONT)
14613         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14614       if (mask & ELF_SPARC_HWCAP2_NSEC)
14615         printf ("%snsec", first ? "" : "|"), first = FALSE;
14616       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14617         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14618       if (mask & ELF_SPARC_HWCAP2_FJDES)
14619         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14620       if (mask & ELF_SPARC_HWCAP2_FJAES)
14621         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14622     }
14623   else
14624     fputc ('0', stdout);
14625   fputc ('\n', stdout);
14626 }
14627
14628 static unsigned char *
14629 display_sparc_gnu_attribute (unsigned char * p,
14630                              unsigned int tag,
14631                              const unsigned char * const end)
14632 {
14633   unsigned int len;
14634   int val;
14635
14636   if (tag == Tag_GNU_Sparc_HWCAPS)
14637     {
14638       val = read_uleb128 (p, &len, end);
14639       p += len;
14640       printf ("  Tag_GNU_Sparc_HWCAPS: ");
14641       display_sparc_hwcaps (val);
14642       return p;
14643     }
14644   if (tag == Tag_GNU_Sparc_HWCAPS2)
14645     {
14646       val = read_uleb128 (p, &len, end);
14647       p += len;
14648       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
14649       display_sparc_hwcaps2 (val);
14650       return p;
14651     }
14652
14653   return display_tag_value (tag, p, end);
14654 }
14655
14656 static void
14657 print_mips_fp_abi_value (unsigned int val)
14658 {
14659   switch (val)
14660     {
14661     case Val_GNU_MIPS_ABI_FP_ANY:
14662       printf (_("Hard or soft float\n"));
14663       break;
14664     case Val_GNU_MIPS_ABI_FP_DOUBLE:
14665       printf (_("Hard float (double precision)\n"));
14666       break;
14667     case Val_GNU_MIPS_ABI_FP_SINGLE:
14668       printf (_("Hard float (single precision)\n"));
14669       break;
14670     case Val_GNU_MIPS_ABI_FP_SOFT:
14671       printf (_("Soft float\n"));
14672       break;
14673     case Val_GNU_MIPS_ABI_FP_OLD_64:
14674       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14675       break;
14676     case Val_GNU_MIPS_ABI_FP_XX:
14677       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14678       break;
14679     case Val_GNU_MIPS_ABI_FP_64:
14680       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14681       break;
14682     case Val_GNU_MIPS_ABI_FP_64A:
14683       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14684       break;
14685     case Val_GNU_MIPS_ABI_FP_NAN2008:
14686       printf (_("NaN 2008 compatibility\n"));
14687       break;
14688     default:
14689       printf ("??? (%d)\n", val);
14690       break;
14691     }
14692 }
14693
14694 static unsigned char *
14695 display_mips_gnu_attribute (unsigned char * p,
14696                             unsigned int tag,
14697                             const unsigned char * const end)
14698 {
14699   if (tag == Tag_GNU_MIPS_ABI_FP)
14700     {
14701       unsigned int len;
14702       unsigned int val;
14703
14704       val = read_uleb128 (p, &len, end);
14705       p += len;
14706       printf ("  Tag_GNU_MIPS_ABI_FP: ");
14707
14708       print_mips_fp_abi_value (val);
14709
14710       return p;
14711    }
14712
14713   if (tag == Tag_GNU_MIPS_ABI_MSA)
14714     {
14715       unsigned int len;
14716       unsigned int val;
14717
14718       val = read_uleb128 (p, &len, end);
14719       p += len;
14720       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
14721
14722       switch (val)
14723         {
14724         case Val_GNU_MIPS_ABI_MSA_ANY:
14725           printf (_("Any MSA or not\n"));
14726           break;
14727         case Val_GNU_MIPS_ABI_MSA_128:
14728           printf (_("128-bit MSA\n"));
14729           break;
14730         default:
14731           printf ("??? (%d)\n", val);
14732           break;
14733         }
14734       return p;
14735     }
14736
14737   return display_tag_value (tag & 1, p, end);
14738 }
14739
14740 static unsigned char *
14741 display_tic6x_attribute (unsigned char * p,
14742                          const unsigned char * const end)
14743 {
14744   unsigned int tag;
14745   unsigned int len;
14746   int val;
14747
14748   tag = read_uleb128 (p, &len, end);
14749   p += len;
14750
14751   switch (tag)
14752     {
14753     case Tag_ISA:
14754       val = read_uleb128 (p, &len, end);
14755       p += len;
14756       printf ("  Tag_ISA: ");
14757
14758       switch (val)
14759         {
14760         case C6XABI_Tag_ISA_none:
14761           printf (_("None\n"));
14762           break;
14763         case C6XABI_Tag_ISA_C62X:
14764           printf ("C62x\n");
14765           break;
14766         case C6XABI_Tag_ISA_C67X:
14767           printf ("C67x\n");
14768           break;
14769         case C6XABI_Tag_ISA_C67XP:
14770           printf ("C67x+\n");
14771           break;
14772         case C6XABI_Tag_ISA_C64X:
14773           printf ("C64x\n");
14774           break;
14775         case C6XABI_Tag_ISA_C64XP:
14776           printf ("C64x+\n");
14777           break;
14778         case C6XABI_Tag_ISA_C674X:
14779           printf ("C674x\n");
14780           break;
14781         default:
14782           printf ("??? (%d)\n", val);
14783           break;
14784         }
14785       return p;
14786
14787     case Tag_ABI_wchar_t:
14788       val = read_uleb128 (p, &len, end);
14789       p += len;
14790       printf ("  Tag_ABI_wchar_t: ");
14791       switch (val)
14792         {
14793         case 0:
14794           printf (_("Not used\n"));
14795           break;
14796         case 1:
14797           printf (_("2 bytes\n"));
14798           break;
14799         case 2:
14800           printf (_("4 bytes\n"));
14801           break;
14802         default:
14803           printf ("??? (%d)\n", val);
14804           break;
14805         }
14806       return p;
14807
14808     case Tag_ABI_stack_align_needed:
14809       val = read_uleb128 (p, &len, end);
14810       p += len;
14811       printf ("  Tag_ABI_stack_align_needed: ");
14812       switch (val)
14813         {
14814         case 0:
14815           printf (_("8-byte\n"));
14816           break;
14817         case 1:
14818           printf (_("16-byte\n"));
14819           break;
14820         default:
14821           printf ("??? (%d)\n", val);
14822           break;
14823         }
14824       return p;
14825
14826     case Tag_ABI_stack_align_preserved:
14827       val = read_uleb128 (p, &len, end);
14828       p += len;
14829       printf ("  Tag_ABI_stack_align_preserved: ");
14830       switch (val)
14831         {
14832         case 0:
14833           printf (_("8-byte\n"));
14834           break;
14835         case 1:
14836           printf (_("16-byte\n"));
14837           break;
14838         default:
14839           printf ("??? (%d)\n", val);
14840           break;
14841         }
14842       return p;
14843
14844     case Tag_ABI_DSBT:
14845       val = read_uleb128 (p, &len, end);
14846       p += len;
14847       printf ("  Tag_ABI_DSBT: ");
14848       switch (val)
14849         {
14850         case 0:
14851           printf (_("DSBT addressing not used\n"));
14852           break;
14853         case 1:
14854           printf (_("DSBT addressing used\n"));
14855           break;
14856         default:
14857           printf ("??? (%d)\n", val);
14858           break;
14859         }
14860       return p;
14861
14862     case Tag_ABI_PID:
14863       val = read_uleb128 (p, &len, end);
14864       p += len;
14865       printf ("  Tag_ABI_PID: ");
14866       switch (val)
14867         {
14868         case 0:
14869           printf (_("Data addressing position-dependent\n"));
14870           break;
14871         case 1:
14872           printf (_("Data addressing position-independent, GOT near DP\n"));
14873           break;
14874         case 2:
14875           printf (_("Data addressing position-independent, GOT far from DP\n"));
14876           break;
14877         default:
14878           printf ("??? (%d)\n", val);
14879           break;
14880         }
14881       return p;
14882
14883     case Tag_ABI_PIC:
14884       val = read_uleb128 (p, &len, end);
14885       p += len;
14886       printf ("  Tag_ABI_PIC: ");
14887       switch (val)
14888         {
14889         case 0:
14890           printf (_("Code addressing position-dependent\n"));
14891           break;
14892         case 1:
14893           printf (_("Code addressing position-independent\n"));
14894           break;
14895         default:
14896           printf ("??? (%d)\n", val);
14897           break;
14898         }
14899       return p;
14900
14901     case Tag_ABI_array_object_alignment:
14902       val = read_uleb128 (p, &len, end);
14903       p += len;
14904       printf ("  Tag_ABI_array_object_alignment: ");
14905       switch (val)
14906         {
14907         case 0:
14908           printf (_("8-byte\n"));
14909           break;
14910         case 1:
14911           printf (_("4-byte\n"));
14912           break;
14913         case 2:
14914           printf (_("16-byte\n"));
14915           break;
14916         default:
14917           printf ("??? (%d)\n", val);
14918           break;
14919         }
14920       return p;
14921
14922     case Tag_ABI_array_object_align_expected:
14923       val = read_uleb128 (p, &len, end);
14924       p += len;
14925       printf ("  Tag_ABI_array_object_align_expected: ");
14926       switch (val)
14927         {
14928         case 0:
14929           printf (_("8-byte\n"));
14930           break;
14931         case 1:
14932           printf (_("4-byte\n"));
14933           break;
14934         case 2:
14935           printf (_("16-byte\n"));
14936           break;
14937         default:
14938           printf ("??? (%d)\n", val);
14939           break;
14940         }
14941       return p;
14942
14943     case Tag_ABI_compatibility:
14944       {
14945         val = read_uleb128 (p, &len, end);
14946         p += len;
14947         printf ("  Tag_ABI_compatibility: ");
14948         printf (_("flag = %d, vendor = "), val);
14949         if (p < end - 1)
14950           {
14951             size_t maxlen = (end - p) - 1;
14952
14953             print_symbol ((int) maxlen, (const char *) p);
14954             p += strnlen ((char *) p, maxlen) + 1;
14955           }
14956         else
14957           {
14958             printf (_("<corrupt>"));
14959             p = (unsigned char *) end;
14960           }
14961         putchar ('\n');
14962         return p;
14963       }
14964
14965     case Tag_ABI_conformance:
14966       {
14967         printf ("  Tag_ABI_conformance: \"");
14968         if (p < end - 1)
14969           {
14970             size_t maxlen = (end - p) - 1;
14971
14972             print_symbol ((int) maxlen, (const char *) p);
14973             p += strnlen ((char *) p, maxlen) + 1;
14974           }
14975         else
14976           {
14977             printf (_("<corrupt>"));
14978             p = (unsigned char *) end;
14979           }
14980         printf ("\"\n");
14981         return p;
14982       }
14983     }
14984
14985   return display_tag_value (tag, p, end);
14986 }
14987
14988 static void
14989 display_raw_attribute (unsigned char * p, unsigned char const * const end)
14990 {
14991   unsigned long addr = 0;
14992   size_t bytes = end - p;
14993
14994   assert (end > p);
14995   while (bytes)
14996     {
14997       int j;
14998       int k;
14999       int lbytes = (bytes > 16 ? 16 : bytes);
15000
15001       printf ("  0x%8.8lx ", addr);
15002
15003       for (j = 0; j < 16; j++)
15004         {
15005           if (j < lbytes)
15006             printf ("%2.2x", p[j]);
15007           else
15008             printf ("  ");
15009
15010           if ((j & 3) == 3)
15011             printf (" ");
15012         }
15013
15014       for (j = 0; j < lbytes; j++)
15015         {
15016           k = p[j];
15017           if (k >= ' ' && k < 0x7f)
15018             printf ("%c", k);
15019           else
15020             printf (".");
15021         }
15022
15023       putchar ('\n');
15024
15025       p  += lbytes;
15026       bytes -= lbytes;
15027       addr += lbytes;
15028     }
15029
15030   putchar ('\n');
15031 }
15032
15033 static unsigned char *
15034 display_msp430x_attribute (unsigned char * p,
15035                            const unsigned char * const end)
15036 {
15037   unsigned int len;
15038   unsigned int val;
15039   unsigned int tag;
15040
15041   tag = read_uleb128 (p, & len, end);
15042   p += len;
15043
15044   switch (tag)
15045     {
15046     case OFBA_MSPABI_Tag_ISA:
15047       val = read_uleb128 (p, &len, end);
15048       p += len;
15049       printf ("  Tag_ISA: ");
15050       switch (val)
15051         {
15052         case 0: printf (_("None\n")); break;
15053         case 1: printf (_("MSP430\n")); break;
15054         case 2: printf (_("MSP430X\n")); break;
15055         default: printf ("??? (%d)\n", val); break;
15056         }
15057       break;
15058
15059     case OFBA_MSPABI_Tag_Code_Model:
15060       val = read_uleb128 (p, &len, end);
15061       p += len;
15062       printf ("  Tag_Code_Model: ");
15063       switch (val)
15064         {
15065         case 0: printf (_("None\n")); break;
15066         case 1: printf (_("Small\n")); break;
15067         case 2: printf (_("Large\n")); break;
15068         default: printf ("??? (%d)\n", val); break;
15069         }
15070       break;
15071
15072     case OFBA_MSPABI_Tag_Data_Model:
15073       val = read_uleb128 (p, &len, end);
15074       p += len;
15075       printf ("  Tag_Data_Model: ");
15076       switch (val)
15077         {
15078         case 0: printf (_("None\n")); break;
15079         case 1: printf (_("Small\n")); break;
15080         case 2: printf (_("Large\n")); break;
15081         case 3: printf (_("Restricted Large\n")); break;
15082         default: printf ("??? (%d)\n", val); break;
15083         }
15084       break;
15085
15086     default:
15087       printf (_("  <unknown tag %d>: "), tag);
15088
15089       if (tag & 1)
15090         {
15091           putchar ('"');
15092           if (p < end - 1)
15093             {
15094               size_t maxlen = (end - p) - 1;
15095
15096               print_symbol ((int) maxlen, (const char *) p);
15097               p += strnlen ((char *) p, maxlen) + 1;
15098             }
15099           else
15100             {
15101               printf (_("<corrupt>"));
15102               p = (unsigned char *) end;
15103             }
15104           printf ("\"\n");
15105         }
15106       else
15107         {
15108           val = read_uleb128 (p, &len, end);
15109           p += len;
15110           printf ("%d (0x%x)\n", val, val);
15111         }
15112       break;
15113    }
15114
15115   assert (p <= end);
15116   return p;
15117 }
15118
15119 static bfd_boolean
15120 process_attributes (Filedata * filedata,
15121                     const char * public_name,
15122                     unsigned int proc_type,
15123                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15124                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15125 {
15126   Elf_Internal_Shdr * sect;
15127   unsigned i;
15128   bfd_boolean res = TRUE;
15129
15130   /* Find the section header so that we get the size.  */
15131   for (i = 0, sect = filedata->section_headers;
15132        i < filedata->file_header.e_shnum;
15133        i++, sect++)
15134     {
15135       unsigned char * contents;
15136       unsigned char * p;
15137
15138       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15139         continue;
15140
15141       contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15142                                              sect->sh_size, _("attributes"));
15143       if (contents == NULL)
15144         {
15145           res = FALSE;
15146           continue;
15147         }
15148
15149       p = contents;
15150       /* The first character is the version of the attributes.
15151          Currently only version 1, (aka 'A') is recognised here.  */
15152       if (*p != 'A')
15153         {
15154           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15155           res = FALSE;
15156         }
15157       else
15158         {
15159           bfd_vma section_len;
15160
15161           section_len = sect->sh_size - 1;
15162           p++;
15163
15164           while (section_len > 0)
15165             {
15166               bfd_vma attr_len;
15167               unsigned int namelen;
15168               bfd_boolean public_section;
15169               bfd_boolean gnu_section;
15170
15171               if (section_len <= 4)
15172                 {
15173                   error (_("Tag section ends prematurely\n"));
15174                   res = FALSE;
15175                   break;
15176                 }
15177               attr_len = byte_get (p, 4);
15178               p += 4;
15179
15180               if (attr_len > section_len)
15181                 {
15182                   error (_("Bad attribute length (%u > %u)\n"),
15183                           (unsigned) attr_len, (unsigned) section_len);
15184                   attr_len = section_len;
15185                   res = FALSE;
15186                 }
15187               /* PR 17531: file: 001-101425-0.004  */
15188               else if (attr_len < 5)
15189                 {
15190                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
15191                   res = FALSE;
15192                   break;
15193                 }
15194
15195               section_len -= attr_len;
15196               attr_len -= 4;
15197
15198               namelen = strnlen ((char *) p, attr_len) + 1;
15199               if (namelen == 0 || namelen >= attr_len)
15200                 {
15201                   error (_("Corrupt attribute section name\n"));
15202                   res = FALSE;
15203                   break;
15204                 }
15205
15206               printf (_("Attribute Section: "));
15207               print_symbol (INT_MAX, (const char *) p);
15208               putchar ('\n');
15209
15210               if (public_name && streq ((char *) p, public_name))
15211                 public_section = TRUE;
15212               else
15213                 public_section = FALSE;
15214
15215               if (streq ((char *) p, "gnu"))
15216                 gnu_section = TRUE;
15217               else
15218                 gnu_section = FALSE;
15219
15220               p += namelen;
15221               attr_len -= namelen;
15222
15223               while (attr_len > 0 && p < contents + sect->sh_size)
15224                 {
15225                   int tag;
15226                   int val;
15227                   bfd_vma size;
15228                   unsigned char * end;
15229
15230                   /* PR binutils/17531: Safe handling of corrupt files.  */
15231                   if (attr_len < 6)
15232                     {
15233                       error (_("Unused bytes at end of section\n"));
15234                       res = FALSE;
15235                       section_len = 0;
15236                       break;
15237                     }
15238
15239                   tag = *(p++);
15240                   size = byte_get (p, 4);
15241                   if (size > attr_len)
15242                     {
15243                       error (_("Bad subsection length (%u > %u)\n"),
15244                               (unsigned) size, (unsigned) attr_len);
15245                       res = FALSE;
15246                       size = attr_len;
15247                     }
15248                   /* PR binutils/17531: Safe handling of corrupt files.  */
15249                   if (size < 6)
15250                     {
15251                       error (_("Bad subsection length (%u < 6)\n"),
15252                               (unsigned) size);
15253                       res = FALSE;
15254                       section_len = 0;
15255                       break;
15256                     }
15257
15258                   attr_len -= size;
15259                   end = p + size - 1;
15260                   assert (end <= contents + sect->sh_size);
15261                   p += 4;
15262
15263                   switch (tag)
15264                     {
15265                     case 1:
15266                       printf (_("File Attributes\n"));
15267                       break;
15268                     case 2:
15269                       printf (_("Section Attributes:"));
15270                       goto do_numlist;
15271                     case 3:
15272                       printf (_("Symbol Attributes:"));
15273                       /* Fall through.  */
15274                     do_numlist:
15275                       for (;;)
15276                         {
15277                           unsigned int j;
15278
15279                           val = read_uleb128 (p, &j, end);
15280                           p += j;
15281                           if (val == 0)
15282                             break;
15283                           printf (" %d", val);
15284                         }
15285                       printf ("\n");
15286                       break;
15287                     default:
15288                       printf (_("Unknown tag: %d\n"), tag);
15289                       public_section = FALSE;
15290                       break;
15291                     }
15292
15293                   if (public_section && display_pub_attribute != NULL)
15294                     {
15295                       while (p < end)
15296                         p = display_pub_attribute (p, end);
15297                       assert (p == end);
15298                     }
15299                   else if (gnu_section && display_proc_gnu_attribute != NULL)
15300                     {
15301                       while (p < end)
15302                         p = display_gnu_attribute (p,
15303                                                    display_proc_gnu_attribute,
15304                                                    end);
15305                       assert (p == end);
15306                     }
15307                   else if (p < end)
15308                     {
15309                       printf (_("  Unknown attribute:\n"));
15310                       display_raw_attribute (p, end);
15311                       p = end;
15312                     }
15313                   else
15314                     attr_len = 0;
15315                 }
15316             }
15317         }
15318
15319       free (contents);
15320     }
15321
15322   return res;
15323 }
15324
15325 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15326    Print the Address, Access and Initial fields of an entry at VMA ADDR
15327    and return the VMA of the next entry, or -1 if there was a problem.
15328    Does not read from DATA_END or beyond.  */
15329
15330 static bfd_vma
15331 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15332                       unsigned char * data_end)
15333 {
15334   printf ("  ");
15335   print_vma (addr, LONG_HEX);
15336   printf (" ");
15337   if (addr < pltgot + 0xfff0)
15338     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15339   else
15340     printf ("%10s", "");
15341   printf (" ");
15342   if (data == NULL)
15343     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15344   else
15345     {
15346       bfd_vma entry;
15347       unsigned char * from = data + addr - pltgot;
15348
15349       if (from + (is_32bit_elf ? 4 : 8) > data_end)
15350         {
15351           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15352           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15353           return (bfd_vma) -1;
15354         }
15355       else
15356         {
15357           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15358           print_vma (entry, LONG_HEX);
15359         }
15360     }
15361   return addr + (is_32bit_elf ? 4 : 8);
15362 }
15363
15364 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15365    PLTGOT.  Print the Address and Initial fields of an entry at VMA
15366    ADDR and return the VMA of the next entry.  */
15367
15368 static bfd_vma
15369 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15370 {
15371   printf ("  ");
15372   print_vma (addr, LONG_HEX);
15373   printf (" ");
15374   if (data == NULL)
15375     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15376   else
15377     {
15378       bfd_vma entry;
15379
15380       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15381       print_vma (entry, LONG_HEX);
15382     }
15383   return addr + (is_32bit_elf ? 4 : 8);
15384 }
15385
15386 static void
15387 print_mips_ases (unsigned int mask)
15388 {
15389   if (mask & AFL_ASE_DSP)
15390     fputs ("\n\tDSP ASE", stdout);
15391   if (mask & AFL_ASE_DSPR2)
15392     fputs ("\n\tDSP R2 ASE", stdout);
15393   if (mask & AFL_ASE_DSPR3)
15394     fputs ("\n\tDSP R3 ASE", stdout);
15395   if (mask & AFL_ASE_EVA)
15396     fputs ("\n\tEnhanced VA Scheme", stdout);
15397   if (mask & AFL_ASE_MCU)
15398     fputs ("\n\tMCU (MicroController) ASE", stdout);
15399   if (mask & AFL_ASE_MDMX)
15400     fputs ("\n\tMDMX ASE", stdout);
15401   if (mask & AFL_ASE_MIPS3D)
15402     fputs ("\n\tMIPS-3D ASE", stdout);
15403   if (mask & AFL_ASE_MT)
15404     fputs ("\n\tMT ASE", stdout);
15405   if (mask & AFL_ASE_SMARTMIPS)
15406     fputs ("\n\tSmartMIPS ASE", stdout);
15407   if (mask & AFL_ASE_VIRT)
15408     fputs ("\n\tVZ ASE", stdout);
15409   if (mask & AFL_ASE_MSA)
15410     fputs ("\n\tMSA ASE", stdout);
15411   if (mask & AFL_ASE_MIPS16)
15412     fputs ("\n\tMIPS16 ASE", stdout);
15413   if (mask & AFL_ASE_MICROMIPS)
15414     fputs ("\n\tMICROMIPS ASE", stdout);
15415   if (mask & AFL_ASE_XPA)
15416     fputs ("\n\tXPA ASE", stdout);
15417   if (mask & AFL_ASE_MIPS16E2)
15418     fputs ("\n\tMIPS16e2 ASE", stdout);
15419   if (mask == 0)
15420     fprintf (stdout, "\n\t%s", _("None"));
15421   else if ((mask & ~AFL_ASE_MASK) != 0)
15422     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15423 }
15424
15425 static void
15426 print_mips_isa_ext (unsigned int isa_ext)
15427 {
15428   switch (isa_ext)
15429     {
15430     case 0:
15431       fputs (_("None"), stdout);
15432       break;
15433     case AFL_EXT_XLR:
15434       fputs ("RMI XLR", stdout);
15435       break;
15436     case AFL_EXT_OCTEON3:
15437       fputs ("Cavium Networks Octeon3", stdout);
15438       break;
15439     case AFL_EXT_OCTEON2:
15440       fputs ("Cavium Networks Octeon2", stdout);
15441       break;
15442     case AFL_EXT_OCTEONP:
15443       fputs ("Cavium Networks OcteonP", stdout);
15444       break;
15445     case AFL_EXT_LOONGSON_3A:
15446       fputs ("Loongson 3A", stdout);
15447       break;
15448     case AFL_EXT_OCTEON:
15449       fputs ("Cavium Networks Octeon", stdout);
15450       break;
15451     case AFL_EXT_5900:
15452       fputs ("Toshiba R5900", stdout);
15453       break;
15454     case AFL_EXT_4650:
15455       fputs ("MIPS R4650", stdout);
15456       break;
15457     case AFL_EXT_4010:
15458       fputs ("LSI R4010", stdout);
15459       break;
15460     case AFL_EXT_4100:
15461       fputs ("NEC VR4100", stdout);
15462       break;
15463     case AFL_EXT_3900:
15464       fputs ("Toshiba R3900", stdout);
15465       break;
15466     case AFL_EXT_10000:
15467       fputs ("MIPS R10000", stdout);
15468       break;
15469     case AFL_EXT_SB1:
15470       fputs ("Broadcom SB-1", stdout);
15471       break;
15472     case AFL_EXT_4111:
15473       fputs ("NEC VR4111/VR4181", stdout);
15474       break;
15475     case AFL_EXT_4120:
15476       fputs ("NEC VR4120", stdout);
15477       break;
15478     case AFL_EXT_5400:
15479       fputs ("NEC VR5400", stdout);
15480       break;
15481     case AFL_EXT_5500:
15482       fputs ("NEC VR5500", stdout);
15483       break;
15484     case AFL_EXT_LOONGSON_2E:
15485       fputs ("ST Microelectronics Loongson 2E", stdout);
15486       break;
15487     case AFL_EXT_LOONGSON_2F:
15488       fputs ("ST Microelectronics Loongson 2F", stdout);
15489       break;
15490     case AFL_EXT_INTERAPTIV_MR2:
15491       fputs ("Imagination interAptiv MR2", stdout);
15492       break;
15493     default:
15494       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15495     }
15496 }
15497
15498 static signed int
15499 get_mips_reg_size (int reg_size)
15500 {
15501   return (reg_size == AFL_REG_NONE) ? 0
15502          : (reg_size == AFL_REG_32) ? 32
15503          : (reg_size == AFL_REG_64) ? 64
15504          : (reg_size == AFL_REG_128) ? 128
15505          : -1;
15506 }
15507
15508 static bfd_boolean
15509 process_mips_specific (Filedata * filedata)
15510 {
15511   Elf_Internal_Dyn * entry;
15512   Elf_Internal_Shdr *sect = NULL;
15513   size_t liblist_offset = 0;
15514   size_t liblistno = 0;
15515   size_t conflictsno = 0;
15516   size_t options_offset = 0;
15517   size_t conflicts_offset = 0;
15518   size_t pltrelsz = 0;
15519   size_t pltrel = 0;
15520   bfd_vma pltgot = 0;
15521   bfd_vma mips_pltgot = 0;
15522   bfd_vma jmprel = 0;
15523   bfd_vma local_gotno = 0;
15524   bfd_vma gotsym = 0;
15525   bfd_vma symtabno = 0;
15526   bfd_boolean res = TRUE;
15527
15528   if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
15529                             display_mips_gnu_attribute))
15530     res = FALSE;
15531
15532   sect = find_section (filedata, ".MIPS.abiflags");
15533
15534   if (sect != NULL)
15535     {
15536       Elf_External_ABIFlags_v0 *abiflags_ext;
15537       Elf_Internal_ABIFlags_v0 abiflags_in;
15538
15539       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15540         {
15541           error (_("Corrupt MIPS ABI Flags section.\n"));
15542           res = FALSE;
15543         }
15544       else
15545         {
15546           abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
15547                                    sect->sh_size, _("MIPS ABI Flags section"));
15548           if (abiflags_ext)
15549             {
15550               abiflags_in.version = BYTE_GET (abiflags_ext->version);
15551               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15552               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15553               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15554               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15555               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15556               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15557               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15558               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15559               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15560               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15561
15562               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15563               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15564               if (abiflags_in.isa_rev > 1)
15565                 printf ("r%d", abiflags_in.isa_rev);
15566               printf ("\nGPR size: %d",
15567                       get_mips_reg_size (abiflags_in.gpr_size));
15568               printf ("\nCPR1 size: %d",
15569                       get_mips_reg_size (abiflags_in.cpr1_size));
15570               printf ("\nCPR2 size: %d",
15571                       get_mips_reg_size (abiflags_in.cpr2_size));
15572               fputs ("\nFP ABI: ", stdout);
15573               print_mips_fp_abi_value (abiflags_in.fp_abi);
15574               fputs ("ISA Extension: ", stdout);
15575               print_mips_isa_ext (abiflags_in.isa_ext);
15576               fputs ("\nASEs:", stdout);
15577               print_mips_ases (abiflags_in.ases);
15578               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15579               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15580               fputc ('\n', stdout);
15581               free (abiflags_ext);
15582             }
15583         }
15584     }
15585
15586   /* We have a lot of special sections.  Thanks SGI!  */
15587   if (dynamic_section == NULL)
15588     {
15589       /* No dynamic information available.  See if there is static GOT.  */
15590       sect = find_section (filedata, ".got");
15591       if (sect != NULL)
15592         {
15593           unsigned char *data_end;
15594           unsigned char *data;
15595           bfd_vma ent, end;
15596           int addr_size;
15597
15598           pltgot = sect->sh_addr;
15599
15600           ent = pltgot;
15601           addr_size = (is_32bit_elf ? 4 : 8);
15602           end = pltgot + sect->sh_size;
15603
15604           data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
15605                                              end - pltgot, 1,
15606                                              _("Global Offset Table data"));
15607           /* PR 12855: Null data is handled gracefully throughout.  */
15608           data_end = data + (end - pltgot);
15609
15610           printf (_("\nStatic GOT:\n"));
15611           printf (_(" Canonical gp value: "));
15612           print_vma (ent + 0x7ff0, LONG_HEX);
15613           printf ("\n\n");
15614
15615           /* In a dynamic binary GOT[0] is reserved for the dynamic
15616              loader to store the lazy resolver pointer, however in
15617              a static binary it may well have been omitted and GOT
15618              reduced to a table of addresses.
15619              PR 21344: Check for the entry being fully available
15620              before fetching it.  */
15621           if (data
15622               && data + ent - pltgot + addr_size <= data_end
15623               && byte_get (data + ent - pltgot, addr_size) == 0)
15624             {
15625               printf (_(" Reserved entries:\n"));
15626               printf (_("  %*s %10s %*s\n"),
15627                       addr_size * 2, _("Address"), _("Access"),
15628                       addr_size * 2, _("Value"));
15629               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15630               printf ("\n");
15631               if (ent == (bfd_vma) -1)
15632                 goto sgot_print_fail;
15633
15634               /* Check for the MSB of GOT[1] being set, identifying a
15635                  GNU object.  This entry will be used by some runtime
15636                  loaders, to store the module pointer.  Otherwise this
15637                  is an ordinary local entry.
15638                  PR 21344: Check for the entry being fully available
15639                  before fetching it.  */
15640               if (data
15641                   && data + ent - pltgot + addr_size <= data_end
15642                   && (byte_get (data + ent - pltgot, addr_size)
15643                       >> (addr_size * 8 - 1)) != 0)
15644                 {
15645                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15646                   printf ("\n");
15647                   if (ent == (bfd_vma) -1)
15648                     goto sgot_print_fail;
15649                 }
15650               printf ("\n");
15651             }
15652
15653           if (data != NULL && ent < end)
15654             {
15655               printf (_(" Local entries:\n"));
15656               printf ("  %*s %10s %*s\n",
15657                       addr_size * 2, _("Address"), _("Access"),
15658                       addr_size * 2, _("Value"));
15659               while (ent < end)
15660                 {
15661                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15662                   printf ("\n");
15663                   if (ent == (bfd_vma) -1)
15664                     goto sgot_print_fail;
15665                 }
15666               printf ("\n");
15667             }
15668
15669         sgot_print_fail:
15670           if (data)
15671             free (data);
15672         }
15673       return res;
15674     }
15675
15676   for (entry = dynamic_section;
15677        /* PR 17531 file: 012-50589-0.004.  */
15678        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15679        ++entry)
15680     switch (entry->d_tag)
15681       {
15682       case DT_MIPS_LIBLIST:
15683         liblist_offset
15684           = offset_from_vma (filedata, entry->d_un.d_val,
15685                              liblistno * sizeof (Elf32_External_Lib));
15686         break;
15687       case DT_MIPS_LIBLISTNO:
15688         liblistno = entry->d_un.d_val;
15689         break;
15690       case DT_MIPS_OPTIONS:
15691         options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
15692         break;
15693       case DT_MIPS_CONFLICT:
15694         conflicts_offset
15695           = offset_from_vma (filedata, entry->d_un.d_val,
15696                              conflictsno * sizeof (Elf32_External_Conflict));
15697         break;
15698       case DT_MIPS_CONFLICTNO:
15699         conflictsno = entry->d_un.d_val;
15700         break;
15701       case DT_PLTGOT:
15702         pltgot = entry->d_un.d_ptr;
15703         break;
15704       case DT_MIPS_LOCAL_GOTNO:
15705         local_gotno = entry->d_un.d_val;
15706         break;
15707       case DT_MIPS_GOTSYM:
15708         gotsym = entry->d_un.d_val;
15709         break;
15710       case DT_MIPS_SYMTABNO:
15711         symtabno = entry->d_un.d_val;
15712         break;
15713       case DT_MIPS_PLTGOT:
15714         mips_pltgot = entry->d_un.d_ptr;
15715         break;
15716       case DT_PLTREL:
15717         pltrel = entry->d_un.d_val;
15718         break;
15719       case DT_PLTRELSZ:
15720         pltrelsz = entry->d_un.d_val;
15721         break;
15722       case DT_JMPREL:
15723         jmprel = entry->d_un.d_ptr;
15724         break;
15725       default:
15726         break;
15727       }
15728
15729   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15730     {
15731       Elf32_External_Lib * elib;
15732       size_t cnt;
15733
15734       elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
15735                                               liblistno,
15736                                               sizeof (Elf32_External_Lib),
15737                                               _("liblist section data"));
15738       if (elib)
15739         {
15740           printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15741                             "\nSection '.liblist' contains %lu entries:\n",
15742                             (unsigned long) liblistno),
15743                   (unsigned long) liblistno);
15744           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
15745                  stdout);
15746
15747           for (cnt = 0; cnt < liblistno; ++cnt)
15748             {
15749               Elf32_Lib liblist;
15750               time_t atime;
15751               char timebuf[128];
15752               struct tm * tmp;
15753
15754               liblist.l_name = BYTE_GET (elib[cnt].l_name);
15755               atime = BYTE_GET (elib[cnt].l_time_stamp);
15756               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15757               liblist.l_version = BYTE_GET (elib[cnt].l_version);
15758               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15759
15760               tmp = gmtime (&atime);
15761               snprintf (timebuf, sizeof (timebuf),
15762                         "%04u-%02u-%02uT%02u:%02u:%02u",
15763                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15764                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15765
15766               printf ("%3lu: ", (unsigned long) cnt);
15767               if (VALID_DYNAMIC_NAME (liblist.l_name))
15768                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
15769               else
15770                 printf (_("<corrupt: %9ld>"), liblist.l_name);
15771               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
15772                       liblist.l_version);
15773
15774               if (liblist.l_flags == 0)
15775                 puts (_(" NONE"));
15776               else
15777                 {
15778                   static const struct
15779                   {
15780                     const char * name;
15781                     int bit;
15782                   }
15783                   l_flags_vals[] =
15784                   {
15785                     { " EXACT_MATCH", LL_EXACT_MATCH },
15786                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
15787                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
15788                     { " EXPORTS", LL_EXPORTS },
15789                     { " DELAY_LOAD", LL_DELAY_LOAD },
15790                     { " DELTA", LL_DELTA }
15791                   };
15792                   int flags = liblist.l_flags;
15793                   size_t fcnt;
15794
15795                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
15796                     if ((flags & l_flags_vals[fcnt].bit) != 0)
15797                       {
15798                         fputs (l_flags_vals[fcnt].name, stdout);
15799                         flags ^= l_flags_vals[fcnt].bit;
15800                       }
15801                   if (flags != 0)
15802                     printf (" %#x", (unsigned int) flags);
15803
15804                   puts ("");
15805                 }
15806             }
15807
15808           free (elib);
15809         }
15810       else
15811         res = FALSE;
15812     }
15813
15814   if (options_offset != 0)
15815     {
15816       Elf_External_Options * eopt;
15817       Elf_Internal_Options * iopt;
15818       Elf_Internal_Options * option;
15819       size_t offset;
15820       int cnt;
15821       sect = filedata->section_headers;
15822
15823       /* Find the section header so that we get the size.  */
15824       sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
15825       /* PR 17533 file: 012-277276-0.004.  */
15826       if (sect == NULL)
15827         {
15828           error (_("No MIPS_OPTIONS header found\n"));
15829           return FALSE;
15830         }
15831
15832       eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
15833                                                 sect->sh_size, _("options"));
15834       if (eopt)
15835         {
15836           iopt = (Elf_Internal_Options *)
15837               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
15838           if (iopt == NULL)
15839             {
15840               error (_("Out of memory allocating space for MIPS options\n"));
15841               return FALSE;
15842             }
15843
15844           offset = cnt = 0;
15845           option = iopt;
15846
15847           while (offset <= sect->sh_size - sizeof (* eopt))
15848             {
15849               Elf_External_Options * eoption;
15850
15851               eoption = (Elf_External_Options *) ((char *) eopt + offset);
15852
15853               option->kind = BYTE_GET (eoption->kind);
15854               option->size = BYTE_GET (eoption->size);
15855               option->section = BYTE_GET (eoption->section);
15856               option->info = BYTE_GET (eoption->info);
15857
15858               /* PR 17531: file: ffa0fa3b.  */
15859               if (option->size < sizeof (* eopt)
15860                   || offset + option->size > sect->sh_size)
15861                 {
15862                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
15863                   return FALSE;
15864                 }
15865               offset += option->size;
15866
15867               ++option;
15868               ++cnt;
15869             }
15870
15871           printf (ngettext ("\nSection '%s' contains %d entry:\n",
15872                             "\nSection '%s' contains %d entries:\n",
15873                             cnt),
15874                   printable_section_name (filedata, sect), cnt);
15875
15876           option = iopt;
15877           offset = 0;
15878
15879           while (cnt-- > 0)
15880             {
15881               size_t len;
15882
15883               switch (option->kind)
15884                 {
15885                 case ODK_NULL:
15886                   /* This shouldn't happen.  */
15887                   printf (" NULL       %d %lx", option->section, option->info);
15888                   break;
15889                 case ODK_REGINFO:
15890                   printf (" REGINFO    ");
15891                   if (filedata->file_header.e_machine == EM_MIPS)
15892                     {
15893                       /* 32bit form.  */
15894                       Elf32_External_RegInfo * ereg;
15895                       Elf32_RegInfo reginfo;
15896
15897                       ereg = (Elf32_External_RegInfo *) (option + 1);
15898                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15899                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15900                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15901                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15902                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15903                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
15904
15905                       printf ("GPR %08lx  GP 0x%lx\n",
15906                               reginfo.ri_gprmask,
15907                               (unsigned long) reginfo.ri_gp_value);
15908                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15909                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15910                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15911                     }
15912                   else
15913                     {
15914                       /* 64 bit form.  */
15915                       Elf64_External_RegInfo * ereg;
15916                       Elf64_Internal_RegInfo reginfo;
15917
15918                       ereg = (Elf64_External_RegInfo *) (option + 1);
15919                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
15920                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15921                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15922                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15923                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15924                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
15925
15926                       printf ("GPR %08lx  GP 0x",
15927                               reginfo.ri_gprmask);
15928                       printf_vma (reginfo.ri_gp_value);
15929                       printf ("\n");
15930
15931                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15932                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15933                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15934                     }
15935                   ++option;
15936                   continue;
15937                 case ODK_EXCEPTIONS:
15938                   fputs (" EXCEPTIONS fpe_min(", stdout);
15939                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
15940                   fputs (") fpe_max(", stdout);
15941                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
15942                   fputs (")", stdout);
15943
15944                   if (option->info & OEX_PAGE0)
15945                     fputs (" PAGE0", stdout);
15946                   if (option->info & OEX_SMM)
15947                     fputs (" SMM", stdout);
15948                   if (option->info & OEX_FPDBUG)
15949                     fputs (" FPDBUG", stdout);
15950                   if (option->info & OEX_DISMISS)
15951                     fputs (" DISMISS", stdout);
15952                   break;
15953                 case ODK_PAD:
15954                   fputs (" PAD       ", stdout);
15955                   if (option->info & OPAD_PREFIX)
15956                     fputs (" PREFIX", stdout);
15957                   if (option->info & OPAD_POSTFIX)
15958                     fputs (" POSTFIX", stdout);
15959                   if (option->info & OPAD_SYMBOL)
15960                     fputs (" SYMBOL", stdout);
15961                   break;
15962                 case ODK_HWPATCH:
15963                   fputs (" HWPATCH   ", stdout);
15964                   if (option->info & OHW_R4KEOP)
15965                     fputs (" R4KEOP", stdout);
15966                   if (option->info & OHW_R8KPFETCH)
15967                     fputs (" R8KPFETCH", stdout);
15968                   if (option->info & OHW_R5KEOP)
15969                     fputs (" R5KEOP", stdout);
15970                   if (option->info & OHW_R5KCVTL)
15971                     fputs (" R5KCVTL", stdout);
15972                   break;
15973                 case ODK_FILL:
15974                   fputs (" FILL       ", stdout);
15975                   /* XXX Print content of info word?  */
15976                   break;
15977                 case ODK_TAGS:
15978                   fputs (" TAGS       ", stdout);
15979                   /* XXX Print content of info word?  */
15980                   break;
15981                 case ODK_HWAND:
15982                   fputs (" HWAND     ", 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_HWOR:
15989                   fputs (" HWOR      ", stdout);
15990                   if (option->info & OHWA0_R4KEOP_CHECKED)
15991                     fputs (" R4KEOP_CHECKED", stdout);
15992                   if (option->info & OHWA0_R4KEOP_CLEAN)
15993                     fputs (" R4KEOP_CLEAN", stdout);
15994                   break;
15995                 case ODK_GP_GROUP:
15996                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
15997                           option->info & OGP_GROUP,
15998                           (option->info & OGP_SELF) >> 16);
15999                   break;
16000                 case ODK_IDENT:
16001                   printf (" IDENT     %#06lx  self-contained %#06lx",
16002                           option->info & OGP_GROUP,
16003                           (option->info & OGP_SELF) >> 16);
16004                   break;
16005                 default:
16006                   /* This shouldn't happen.  */
16007                   printf (" %3d ???     %d %lx",
16008                           option->kind, option->section, option->info);
16009                   break;
16010                 }
16011
16012               len = sizeof (* eopt);
16013               while (len < option->size)
16014                 {
16015                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
16016
16017                   if (ISPRINT (datum))
16018                     printf ("%c", datum);
16019                   else
16020                     printf ("\\%03o", datum);
16021                   len ++;
16022                 }
16023               fputs ("\n", stdout);
16024
16025               offset += option->size;
16026               ++option;
16027             }
16028
16029           free (eopt);
16030         }
16031       else
16032         res = FALSE;
16033     }
16034
16035   if (conflicts_offset != 0 && conflictsno != 0)
16036     {
16037       Elf32_Conflict * iconf;
16038       size_t cnt;
16039
16040       if (dynamic_symbols == NULL)
16041         {
16042           error (_("conflict list found without a dynamic symbol table\n"));
16043           return FALSE;
16044         }
16045
16046       /* PR 21345 - print a slightly more helpful error message
16047          if we are sure that the cmalloc will fail.  */
16048       if (conflictsno * sizeof (* iconf) > filedata->file_size)
16049         {
16050           error (_("Overlarge number of conflicts detected: %lx\n"),
16051                  (long) conflictsno);
16052           return FALSE;
16053         }
16054
16055       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16056       if (iconf == NULL)
16057         {
16058           error (_("Out of memory allocating space for dynamic conflicts\n"));
16059           return FALSE;
16060         }
16061
16062       if (is_32bit_elf)
16063         {
16064           Elf32_External_Conflict * econf32;
16065
16066           econf32 = (Elf32_External_Conflict *)
16067               get_data (NULL, filedata, conflicts_offset, conflictsno,
16068                         sizeof (* econf32), _("conflict"));
16069           if (!econf32)
16070             return FALSE;
16071
16072           for (cnt = 0; cnt < conflictsno; ++cnt)
16073             iconf[cnt] = BYTE_GET (econf32[cnt]);
16074
16075           free (econf32);
16076         }
16077       else
16078         {
16079           Elf64_External_Conflict * econf64;
16080
16081           econf64 = (Elf64_External_Conflict *)
16082               get_data (NULL, filedata, conflicts_offset, conflictsno,
16083                         sizeof (* econf64), _("conflict"));
16084           if (!econf64)
16085             return FALSE;
16086
16087           for (cnt = 0; cnt < conflictsno; ++cnt)
16088             iconf[cnt] = BYTE_GET (econf64[cnt]);
16089
16090           free (econf64);
16091         }
16092
16093       printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16094                         "\nSection '.conflict' contains %lu entries:\n",
16095                         (unsigned long) conflictsno),
16096               (unsigned long) conflictsno);
16097       puts (_("  Num:    Index       Value  Name"));
16098
16099       for (cnt = 0; cnt < conflictsno; ++cnt)
16100         {
16101           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
16102
16103           if (iconf[cnt] >= num_dynamic_syms)
16104             printf (_("<corrupt symbol index>"));
16105           else
16106             {
16107               Elf_Internal_Sym * psym;
16108
16109               psym = & dynamic_symbols[iconf[cnt]];
16110               print_vma (psym->st_value, FULL_HEX);
16111               putchar (' ');
16112               if (VALID_DYNAMIC_NAME (psym->st_name))
16113                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16114               else
16115                 printf (_("<corrupt: %14ld>"), psym->st_name);
16116             }
16117           putchar ('\n');
16118         }
16119
16120       free (iconf);
16121     }
16122
16123   if (pltgot != 0 && local_gotno != 0)
16124     {
16125       bfd_vma ent, local_end, global_end;
16126       size_t i, offset;
16127       unsigned char * data;
16128       unsigned char * data_end;
16129       int addr_size;
16130
16131       ent = pltgot;
16132       addr_size = (is_32bit_elf ? 4 : 8);
16133       local_end = pltgot + local_gotno * addr_size;
16134
16135       /* PR binutils/17533 file: 012-111227-0.004  */
16136       if (symtabno < gotsym)
16137         {
16138           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16139                  (unsigned long) gotsym, (unsigned long) symtabno);
16140           return FALSE;
16141         }
16142
16143       global_end = local_end + (symtabno - gotsym) * addr_size;
16144       /* PR 17531: file: 54c91a34.  */
16145       if (global_end < local_end)
16146         {
16147           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
16148           return FALSE;
16149         }
16150
16151       offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
16152       data = (unsigned char *) get_data (NULL, filedata, offset,
16153                                          global_end - pltgot, 1,
16154                                          _("Global Offset Table data"));
16155       /* PR 12855: Null data is handled gracefully throughout.  */
16156       data_end = data + (global_end - pltgot);
16157
16158       printf (_("\nPrimary GOT:\n"));
16159       printf (_(" Canonical gp value: "));
16160       print_vma (pltgot + 0x7ff0, LONG_HEX);
16161       printf ("\n\n");
16162
16163       printf (_(" Reserved entries:\n"));
16164       printf (_("  %*s %10s %*s Purpose\n"),
16165               addr_size * 2, _("Address"), _("Access"),
16166               addr_size * 2, _("Initial"));
16167       ent = print_mips_got_entry (data, pltgot, ent, data_end);
16168       printf (_(" Lazy resolver\n"));
16169       if (ent == (bfd_vma) -1)
16170         goto got_print_fail;
16171
16172       /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16173          This entry will be used by some runtime loaders, to store the
16174          module pointer.  Otherwise this is an ordinary local entry.
16175          PR 21344: Check for the entry being fully available before
16176          fetching it.  */
16177       if (data
16178           && data + ent - pltgot + addr_size <= data_end
16179           && (byte_get (data + ent - pltgot, addr_size)
16180               >> (addr_size * 8 - 1)) != 0)
16181         {
16182           ent = print_mips_got_entry (data, pltgot, ent, data_end);
16183           printf (_(" Module pointer (GNU extension)\n"));
16184           if (ent == (bfd_vma) -1)
16185             goto got_print_fail;
16186         }
16187       printf ("\n");
16188
16189       if (data != NULL && ent < local_end)
16190         {
16191           printf (_(" Local entries:\n"));
16192           printf ("  %*s %10s %*s\n",
16193                   addr_size * 2, _("Address"), _("Access"),
16194                   addr_size * 2, _("Initial"));
16195           while (ent < local_end)
16196             {
16197               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16198               printf ("\n");
16199               if (ent == (bfd_vma) -1)
16200                 goto got_print_fail;
16201             }
16202           printf ("\n");
16203         }
16204
16205       if (data != NULL && gotsym < symtabno)
16206         {
16207           int sym_width;
16208
16209           printf (_(" Global entries:\n"));
16210           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
16211                   addr_size * 2, _("Address"),
16212                   _("Access"),
16213                   addr_size * 2, _("Initial"),
16214                   addr_size * 2, _("Sym.Val."),
16215                   _("Type"),
16216                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
16217                   _("Ndx"), _("Name"));
16218
16219           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
16220
16221           for (i = gotsym; i < symtabno; i++)
16222             {
16223               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16224               printf (" ");
16225
16226               if (dynamic_symbols == NULL)
16227                 printf (_("<no dynamic symbols>"));
16228               else if (i < num_dynamic_syms)
16229                 {
16230                   Elf_Internal_Sym * psym = dynamic_symbols + i;
16231
16232                   print_vma (psym->st_value, LONG_HEX);
16233                   printf (" %-7s %3s ",
16234                           get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16235                           get_symbol_index_type (filedata, psym->st_shndx));
16236
16237                   if (VALID_DYNAMIC_NAME (psym->st_name))
16238                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16239                   else
16240                     printf (_("<corrupt: %14ld>"), psym->st_name);
16241                 }
16242               else
16243                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16244                         (unsigned long) i);
16245
16246               printf ("\n");
16247               if (ent == (bfd_vma) -1)
16248                 break;
16249             }
16250           printf ("\n");
16251         }
16252
16253     got_print_fail:
16254       if (data)
16255         free (data);
16256     }
16257
16258   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
16259     {
16260       bfd_vma ent, end;
16261       size_t offset, rel_offset;
16262       unsigned long count, i;
16263       unsigned char * data;
16264       int addr_size, sym_width;
16265       Elf_Internal_Rela * rels;
16266
16267       rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
16268       if (pltrel == DT_RELA)
16269         {
16270           if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16271             return FALSE;
16272         }
16273       else
16274         {
16275           if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16276             return FALSE;
16277         }
16278
16279       ent = mips_pltgot;
16280       addr_size = (is_32bit_elf ? 4 : 8);
16281       end = mips_pltgot + (2 + count) * addr_size;
16282
16283       offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
16284       data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
16285                                          1, _("Procedure Linkage Table data"));
16286       if (data == NULL)
16287         return FALSE;
16288
16289       printf ("\nPLT GOT:\n\n");
16290       printf (_(" Reserved entries:\n"));
16291       printf (_("  %*s %*s Purpose\n"),
16292               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
16293       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16294       printf (_(" PLT lazy resolver\n"));
16295       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16296       printf (_(" Module pointer\n"));
16297       printf ("\n");
16298
16299       printf (_(" Entries:\n"));
16300       printf ("  %*s %*s %*s %-7s %3s %s\n",
16301               addr_size * 2, _("Address"),
16302               addr_size * 2, _("Initial"),
16303               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16304       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
16305       for (i = 0; i < count; i++)
16306         {
16307           unsigned long idx = get_reloc_symindex (rels[i].r_info);
16308
16309           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16310           printf (" ");
16311
16312           if (idx >= num_dynamic_syms)
16313             printf (_("<corrupt symbol index: %lu>"), idx);
16314           else
16315             {
16316               Elf_Internal_Sym * psym = dynamic_symbols + idx;
16317
16318               print_vma (psym->st_value, LONG_HEX);
16319               printf (" %-7s %3s ",
16320                       get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16321                       get_symbol_index_type (filedata, psym->st_shndx));
16322               if (VALID_DYNAMIC_NAME (psym->st_name))
16323                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16324               else
16325                 printf (_("<corrupt: %14ld>"), psym->st_name);
16326             }
16327           printf ("\n");
16328         }
16329       printf ("\n");
16330
16331       if (data)
16332         free (data);
16333       free (rels);
16334     }
16335
16336   return res;
16337 }
16338
16339 static bfd_boolean
16340 process_nds32_specific (Filedata * filedata)
16341 {
16342   Elf_Internal_Shdr *sect = NULL;
16343
16344   sect = find_section (filedata, ".nds32_e_flags");
16345   if (sect != NULL)
16346     {
16347       unsigned int *flag;
16348
16349       printf ("\nNDS32 elf flags section:\n");
16350       flag = get_data (NULL, filedata, sect->sh_offset, 1,
16351                        sect->sh_size, _("NDS32 elf flags section"));
16352
16353       if (! flag)
16354         return FALSE;
16355
16356       switch ((*flag) & 0x3)
16357         {
16358         case 0:
16359           printf ("(VEC_SIZE):\tNo entry.\n");
16360           break;
16361         case 1:
16362           printf ("(VEC_SIZE):\t4 bytes\n");
16363           break;
16364         case 2:
16365           printf ("(VEC_SIZE):\t16 bytes\n");
16366           break;
16367         case 3:
16368           printf ("(VEC_SIZE):\treserved\n");
16369           break;
16370         }
16371     }
16372
16373   return TRUE;
16374 }
16375
16376 static bfd_boolean
16377 process_gnu_liblist (Filedata * filedata)
16378 {
16379   Elf_Internal_Shdr * section;
16380   Elf_Internal_Shdr * string_sec;
16381   Elf32_External_Lib * elib;
16382   char * strtab;
16383   size_t strtab_size;
16384   size_t cnt;
16385   unsigned long num_liblist;
16386   unsigned i;
16387   bfd_boolean res = TRUE;
16388
16389   if (! do_arch)
16390     return TRUE;
16391
16392   for (i = 0, section = filedata->section_headers;
16393        i < filedata->file_header.e_shnum;
16394        i++, section++)
16395     {
16396       switch (section->sh_type)
16397         {
16398         case SHT_GNU_LIBLIST:
16399           if (section->sh_link >= filedata->file_header.e_shnum)
16400             break;
16401
16402           elib = (Elf32_External_Lib *)
16403               get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
16404                         _("liblist section data"));
16405
16406           if (elib == NULL)
16407             {
16408               res = FALSE;
16409               break;
16410             }
16411
16412           string_sec = filedata->section_headers + section->sh_link;
16413           strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
16414                                       string_sec->sh_size,
16415                                       _("liblist string table"));
16416           if (strtab == NULL
16417               || section->sh_entsize != sizeof (Elf32_External_Lib))
16418             {
16419               free (elib);
16420               free (strtab);
16421               res = FALSE;
16422               break;
16423             }
16424           strtab_size = string_sec->sh_size;
16425
16426           num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
16427           printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16428                             "\nLibrary list section '%s' contains %lu entries:\n",
16429                             num_liblist),
16430                   printable_section_name (filedata, section),
16431                   num_liblist);
16432
16433           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
16434
16435           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16436                ++cnt)
16437             {
16438               Elf32_Lib liblist;
16439               time_t atime;
16440               char timebuf[128];
16441               struct tm * tmp;
16442
16443               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16444               atime = BYTE_GET (elib[cnt].l_time_stamp);
16445               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16446               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16447               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16448
16449               tmp = gmtime (&atime);
16450               snprintf (timebuf, sizeof (timebuf),
16451                         "%04u-%02u-%02uT%02u:%02u:%02u",
16452                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16453                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16454
16455               printf ("%3lu: ", (unsigned long) cnt);
16456               if (do_wide)
16457                 printf ("%-20s", liblist.l_name < strtab_size
16458                         ? strtab + liblist.l_name : _("<corrupt>"));
16459               else
16460                 printf ("%-20.20s", liblist.l_name < strtab_size
16461                         ? strtab + liblist.l_name : _("<corrupt>"));
16462               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16463                       liblist.l_version, liblist.l_flags);
16464             }
16465
16466           free (elib);
16467           free (strtab);
16468         }
16469     }
16470
16471   return res;
16472 }
16473
16474 static const char *
16475 get_note_type (Filedata * filedata, unsigned e_type)
16476 {
16477   static char buff[64];
16478
16479   if (filedata->file_header.e_type == ET_CORE)
16480     switch (e_type)
16481       {
16482       case NT_AUXV:
16483         return _("NT_AUXV (auxiliary vector)");
16484       case NT_PRSTATUS:
16485         return _("NT_PRSTATUS (prstatus structure)");
16486       case NT_FPREGSET:
16487         return _("NT_FPREGSET (floating point registers)");
16488       case NT_PRPSINFO:
16489         return _("NT_PRPSINFO (prpsinfo structure)");
16490       case NT_TASKSTRUCT:
16491         return _("NT_TASKSTRUCT (task structure)");
16492       case NT_PRXFPREG:
16493         return _("NT_PRXFPREG (user_xfpregs structure)");
16494       case NT_PPC_VMX:
16495         return _("NT_PPC_VMX (ppc Altivec registers)");
16496       case NT_PPC_VSX:
16497         return _("NT_PPC_VSX (ppc VSX registers)");
16498       case NT_PPC_TAR:
16499         return _("NT_PPC_TAR (ppc TAR register)");
16500       case NT_PPC_PPR:
16501         return _("NT_PPC_PPR (ppc PPR register)");
16502       case NT_PPC_DSCR:
16503         return _("NT_PPC_DSCR (ppc DSCR register)");
16504       case NT_PPC_EBB:
16505         return _("NT_PPC_EBB (ppc EBB registers)");
16506       case NT_PPC_PMU:
16507         return _("NT_PPC_PMU (ppc PMU registers)");
16508       case NT_PPC_TM_CGPR:
16509         return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16510       case NT_PPC_TM_CFPR:
16511         return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16512       case NT_PPC_TM_CVMX:
16513         return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16514       case NT_PPC_TM_CVSX:
16515         return _("NT_PPC_TM_VSX (ppc checkpointed VSX registers)");
16516       case NT_PPC_TM_SPR:
16517         return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16518       case NT_PPC_TM_CTAR:
16519         return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16520       case NT_PPC_TM_CPPR:
16521         return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16522       case NT_PPC_TM_CDSCR:
16523         return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16524       case NT_386_TLS:
16525         return _("NT_386_TLS (x86 TLS information)");
16526       case NT_386_IOPERM:
16527         return _("NT_386_IOPERM (x86 I/O permissions)");
16528       case NT_X86_XSTATE:
16529         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16530       case NT_S390_HIGH_GPRS:
16531         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16532       case NT_S390_TIMER:
16533         return _("NT_S390_TIMER (s390 timer register)");
16534       case NT_S390_TODCMP:
16535         return _("NT_S390_TODCMP (s390 TOD comparator register)");
16536       case NT_S390_TODPREG:
16537         return _("NT_S390_TODPREG (s390 TOD programmable register)");
16538       case NT_S390_CTRS:
16539         return _("NT_S390_CTRS (s390 control registers)");
16540       case NT_S390_PREFIX:
16541         return _("NT_S390_PREFIX (s390 prefix register)");
16542       case NT_S390_LAST_BREAK:
16543         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16544       case NT_S390_SYSTEM_CALL:
16545         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16546       case NT_S390_TDB:
16547         return _("NT_S390_TDB (s390 transaction diagnostic block)");
16548       case NT_S390_VXRS_LOW:
16549         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16550       case NT_S390_VXRS_HIGH:
16551         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16552       case NT_S390_GS_CB:
16553         return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16554       case NT_S390_GS_BC:
16555         return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16556       case NT_ARM_VFP:
16557         return _("NT_ARM_VFP (arm VFP registers)");
16558       case NT_ARM_TLS:
16559         return _("NT_ARM_TLS (AArch TLS registers)");
16560       case NT_ARM_HW_BREAK:
16561         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16562       case NT_ARM_HW_WATCH:
16563         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16564       case NT_PSTATUS:
16565         return _("NT_PSTATUS (pstatus structure)");
16566       case NT_FPREGS:
16567         return _("NT_FPREGS (floating point registers)");
16568       case NT_PSINFO:
16569         return _("NT_PSINFO (psinfo structure)");
16570       case NT_LWPSTATUS:
16571         return _("NT_LWPSTATUS (lwpstatus_t structure)");
16572       case NT_LWPSINFO:
16573         return _("NT_LWPSINFO (lwpsinfo_t structure)");
16574       case NT_WIN32PSTATUS:
16575         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16576       case NT_SIGINFO:
16577         return _("NT_SIGINFO (siginfo_t data)");
16578       case NT_FILE:
16579         return _("NT_FILE (mapped files)");
16580       default:
16581         break;
16582       }
16583   else
16584     switch (e_type)
16585       {
16586       case NT_VERSION:
16587         return _("NT_VERSION (version)");
16588       case NT_ARCH:
16589         return _("NT_ARCH (architecture)");
16590       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16591         return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16592       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16593         return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16594       default:
16595         break;
16596       }
16597
16598   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16599   return buff;
16600 }
16601
16602 static bfd_boolean
16603 print_core_note (Elf_Internal_Note *pnote)
16604 {
16605   unsigned int addr_size = is_32bit_elf ? 4 : 8;
16606   bfd_vma count, page_size;
16607   unsigned char *descdata, *filenames, *descend;
16608
16609   if (pnote->type != NT_FILE)
16610     {
16611       if (do_wide)
16612         printf ("\n");
16613       return TRUE;
16614     }
16615
16616 #ifndef BFD64
16617   if (!is_32bit_elf)
16618     {
16619       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
16620       /* Still "successful".  */
16621       return TRUE;
16622     }
16623 #endif
16624
16625   if (pnote->descsz < 2 * addr_size)
16626     {
16627       error (_("    Malformed note - too short for header\n"));
16628       return FALSE;
16629     }
16630
16631   descdata = (unsigned char *) pnote->descdata;
16632   descend = descdata + pnote->descsz;
16633
16634   if (descdata[pnote->descsz - 1] != '\0')
16635     {
16636       error (_("    Malformed note - does not end with \\0\n"));
16637       return FALSE;
16638     }
16639
16640   count = byte_get (descdata, addr_size);
16641   descdata += addr_size;
16642
16643   page_size = byte_get (descdata, addr_size);
16644   descdata += addr_size;
16645
16646   if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
16647       || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16648     {
16649       error (_("    Malformed note - too short for supplied file count\n"));
16650       return FALSE;
16651     }
16652
16653   printf (_("    Page size: "));
16654   print_vma (page_size, DEC);
16655   printf ("\n");
16656
16657   printf (_("    %*s%*s%*s\n"),
16658           (int) (2 + 2 * addr_size), _("Start"),
16659           (int) (4 + 2 * addr_size), _("End"),
16660           (int) (4 + 2 * addr_size), _("Page Offset"));
16661   filenames = descdata + count * 3 * addr_size;
16662   while (count-- > 0)
16663     {
16664       bfd_vma start, end, file_ofs;
16665
16666       if (filenames == descend)
16667         {
16668           error (_("    Malformed note - filenames end too early\n"));
16669           return FALSE;
16670         }
16671
16672       start = byte_get (descdata, addr_size);
16673       descdata += addr_size;
16674       end = byte_get (descdata, addr_size);
16675       descdata += addr_size;
16676       file_ofs = byte_get (descdata, addr_size);
16677       descdata += addr_size;
16678
16679       printf ("    ");
16680       print_vma (start, FULL_HEX);
16681       printf ("  ");
16682       print_vma (end, FULL_HEX);
16683       printf ("  ");
16684       print_vma (file_ofs, FULL_HEX);
16685       printf ("\n        %s\n", filenames);
16686
16687       filenames += 1 + strlen ((char *) filenames);
16688     }
16689
16690   return TRUE;
16691 }
16692
16693 static const char *
16694 get_gnu_elf_note_type (unsigned e_type)
16695 {
16696   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
16697   switch (e_type)
16698     {
16699     case NT_GNU_ABI_TAG:
16700       return _("NT_GNU_ABI_TAG (ABI version tag)");
16701     case NT_GNU_HWCAP:
16702       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16703     case NT_GNU_BUILD_ID:
16704       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16705     case NT_GNU_GOLD_VERSION:
16706       return _("NT_GNU_GOLD_VERSION (gold version)");
16707     case NT_GNU_PROPERTY_TYPE_0:
16708       return _("NT_GNU_PROPERTY_TYPE_0");
16709     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16710       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16711     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16712       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16713     default:
16714       {
16715         static char buff[64];
16716
16717         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16718         return buff;
16719       }
16720     }
16721 }
16722
16723 static void
16724 decode_x86_isa (unsigned int bitmask)
16725 {
16726   while (bitmask)
16727     {
16728       unsigned int bit = bitmask & (- bitmask);
16729
16730       bitmask &= ~ bit;
16731       switch (bit)
16732         {
16733         case GNU_PROPERTY_X86_ISA_1_486: printf ("i486"); break;
16734         case GNU_PROPERTY_X86_ISA_1_586: printf ("586"); break;
16735         case GNU_PROPERTY_X86_ISA_1_686: printf ("686"); break;
16736         case GNU_PROPERTY_X86_ISA_1_SSE: printf ("SSE"); break;
16737         case GNU_PROPERTY_X86_ISA_1_SSE2: printf ("SSE2"); break;
16738         case GNU_PROPERTY_X86_ISA_1_SSE3: printf ("SSE3"); break;
16739         case GNU_PROPERTY_X86_ISA_1_SSSE3: printf ("SSSE3"); break;
16740         case GNU_PROPERTY_X86_ISA_1_SSE4_1: printf ("SSE4_1"); break;
16741         case GNU_PROPERTY_X86_ISA_1_SSE4_2: printf ("SSE4_2"); break;
16742         case GNU_PROPERTY_X86_ISA_1_AVX: printf ("AVX"); break;
16743         case GNU_PROPERTY_X86_ISA_1_AVX2: printf ("AVX2"); break;
16744         case GNU_PROPERTY_X86_ISA_1_AVX512F: printf ("AVX512F"); break;
16745         case GNU_PROPERTY_X86_ISA_1_AVX512CD: printf ("AVX512CD"); break;
16746         case GNU_PROPERTY_X86_ISA_1_AVX512ER: printf ("AVX512ER"); break;
16747         case GNU_PROPERTY_X86_ISA_1_AVX512PF: printf ("AVX512PF"); break;
16748         case GNU_PROPERTY_X86_ISA_1_AVX512VL: printf ("AVX512VL"); break;
16749         case GNU_PROPERTY_X86_ISA_1_AVX512DQ: printf ("AVX512DQ"); break;
16750         case GNU_PROPERTY_X86_ISA_1_AVX512BW: printf ("AVX512BW"); break;
16751         default: printf (_("<unknown: %x>"), bit); break;
16752         }
16753       if (bitmask)
16754         printf (", ");
16755     }
16756 }
16757
16758 static void
16759 decode_x86_feature (unsigned int type, unsigned int bitmask)
16760 {
16761   while (bitmask)
16762     {
16763       unsigned int bit = bitmask & (- bitmask);
16764
16765       bitmask &= ~ bit;
16766       switch (bit)
16767         {
16768         case GNU_PROPERTY_X86_FEATURE_1_IBT:
16769           switch (type)
16770             {
16771             case GNU_PROPERTY_X86_FEATURE_1_AND:
16772               printf ("IBT");
16773               break;
16774             default:
16775               /* This should never happen.  */
16776               abort ();
16777             }
16778           break;
16779         case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
16780           switch (type)
16781             {
16782             case GNU_PROPERTY_X86_FEATURE_1_AND:
16783               printf ("SHSTK");
16784               break;
16785             default:
16786               /* This should never happen.  */
16787               abort ();
16788             }
16789           break;
16790         default:
16791           printf (_("<unknown: %x>"), bit);
16792           break;
16793         }
16794       if (bitmask)
16795         printf (", ");
16796     }
16797 }
16798
16799 static void
16800 print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
16801 {
16802   unsigned char * ptr = (unsigned char *) pnote->descdata;
16803   unsigned char * ptr_end = ptr + pnote->descsz;
16804   unsigned int    size = is_32bit_elf ? 4 : 8;
16805
16806   printf (_("      Properties: "));
16807
16808   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
16809     {
16810       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
16811       return;
16812     }
16813
16814   while (ptr < ptr_end)
16815     {
16816       unsigned int j;
16817       unsigned int type;
16818       unsigned int datasz;
16819
16820       if ((size_t) (ptr_end - ptr) < 8)
16821         {
16822           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
16823           break;
16824         }
16825
16826       type = byte_get (ptr, 4);
16827       datasz = byte_get (ptr + 4, 4);
16828
16829       ptr += 8;
16830
16831       if (datasz > (size_t) (ptr_end - ptr))
16832         {
16833           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16834                   type, datasz);
16835           break;
16836         }
16837
16838       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
16839         {
16840           if (filedata->file_header.e_machine == EM_X86_64
16841               || filedata->file_header.e_machine == EM_IAMCU
16842               || filedata->file_header.e_machine == EM_386)
16843             {
16844               switch (type)
16845                 {
16846                 case GNU_PROPERTY_X86_ISA_1_USED:
16847                   printf ("x86 ISA used: ");
16848                   if (datasz != 4)
16849                     printf (_("<corrupt length: %#x> "), datasz);
16850                   else
16851                     decode_x86_isa (byte_get (ptr, 4));
16852                   goto next;
16853
16854                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
16855                   printf ("x86 ISA needed: ");
16856                   if (datasz != 4)
16857                     printf (_("<corrupt length: %#x> "), datasz);
16858                   else
16859                     decode_x86_isa (byte_get (ptr, 4));
16860                   goto next;
16861
16862                 case GNU_PROPERTY_X86_FEATURE_1_AND:
16863                   printf ("x86 feature: ");
16864                   if (datasz != 4)
16865                     printf (_("<corrupt length: %#x> "), datasz);
16866                   else
16867                     decode_x86_feature (type, byte_get (ptr, 4));
16868                   goto next;
16869
16870                 default:
16871                   break;
16872                 }
16873             }
16874         }
16875       else
16876         {
16877           switch (type)
16878             {
16879             case GNU_PROPERTY_STACK_SIZE:
16880               printf (_("stack size: "));
16881               if (datasz != size)
16882                 printf (_("<corrupt length: %#x> "), datasz);
16883               else
16884                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
16885               goto next;
16886
16887             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
16888               printf ("no copy on protected ");
16889               if (datasz)
16890                 printf (_("<corrupt length: %#x> "), datasz);
16891               goto next;
16892
16893             default:
16894               break;
16895             }
16896         }
16897
16898       if (type < GNU_PROPERTY_LOPROC)
16899         printf (_("<unknown type %#x data: "), type);
16900       else if (type < GNU_PROPERTY_LOUSER)
16901         printf (_("<procesor-specific type %#x data: "), type);
16902       else
16903         printf (_("<application-specific type %#x data: "), type);
16904       for (j = 0; j < datasz; ++j)
16905         printf ("%02x ", ptr[j] & 0xff);
16906       printf (">");
16907
16908 next:
16909       ptr += ((datasz + (size - 1)) & ~ (size - 1));
16910       if (ptr == ptr_end)
16911         break;
16912
16913       if (do_wide)
16914         printf (", ");
16915       else
16916         printf ("\n\t");
16917     }
16918
16919   printf ("\n");
16920 }
16921
16922 static bfd_boolean
16923 print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
16924 {
16925   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
16926   switch (pnote->type)
16927     {
16928     case NT_GNU_BUILD_ID:
16929       {
16930         unsigned long i;
16931
16932         printf (_("    Build ID: "));
16933         for (i = 0; i < pnote->descsz; ++i)
16934           printf ("%02x", pnote->descdata[i] & 0xff);
16935         printf ("\n");
16936       }
16937       break;
16938
16939     case NT_GNU_ABI_TAG:
16940       {
16941         unsigned long os, major, minor, subminor;
16942         const char *osname;
16943
16944         /* PR 17531: file: 030-599401-0.004.  */
16945         if (pnote->descsz < 16)
16946           {
16947             printf (_("    <corrupt GNU_ABI_TAG>\n"));
16948             break;
16949           }
16950
16951         os = byte_get ((unsigned char *) pnote->descdata, 4);
16952         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16953         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
16954         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
16955
16956         switch (os)
16957           {
16958           case GNU_ABI_TAG_LINUX:
16959             osname = "Linux";
16960             break;
16961           case GNU_ABI_TAG_HURD:
16962             osname = "Hurd";
16963             break;
16964           case GNU_ABI_TAG_SOLARIS:
16965             osname = "Solaris";
16966             break;
16967           case GNU_ABI_TAG_FREEBSD:
16968             osname = "FreeBSD";
16969             break;
16970           case GNU_ABI_TAG_NETBSD:
16971             osname = "NetBSD";
16972             break;
16973           case GNU_ABI_TAG_SYLLABLE:
16974             osname = "Syllable";
16975             break;
16976           case GNU_ABI_TAG_NACL:
16977             osname = "NaCl";
16978             break;
16979           default:
16980             osname = "Unknown";
16981             break;
16982           }
16983
16984         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
16985                 major, minor, subminor);
16986       }
16987       break;
16988
16989     case NT_GNU_GOLD_VERSION:
16990       {
16991         unsigned long i;
16992
16993         printf (_("    Version: "));
16994         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
16995           printf ("%c", pnote->descdata[i]);
16996         printf ("\n");
16997       }
16998       break;
16999
17000     case NT_GNU_HWCAP:
17001       {
17002         unsigned long num_entries, mask;
17003
17004         /* Hardware capabilities information.  Word 0 is the number of entries.
17005            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
17006            is a series of entries, where each entry is a single byte followed
17007            by a nul terminated string.  The byte gives the bit number to test
17008            if enabled in the bitmask.  */
17009         printf (_("      Hardware Capabilities: "));
17010         if (pnote->descsz < 8)
17011           {
17012             error (_("<corrupt GNU_HWCAP>\n"));
17013             return FALSE;
17014           }
17015         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
17016         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17017         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
17018         /* FIXME: Add code to display the entries... */
17019       }
17020       break;
17021
17022     case NT_GNU_PROPERTY_TYPE_0:
17023       print_gnu_property_note (filedata, pnote);
17024       break;
17025
17026     default:
17027       /* Handle unrecognised types.  An error message should have already been
17028          created by get_gnu_elf_note_type(), so all that we need to do is to
17029          display the data.  */
17030       {
17031         unsigned long i;
17032
17033         printf (_("    Description data: "));
17034         for (i = 0; i < pnote->descsz; ++i)
17035           printf ("%02x ", pnote->descdata[i] & 0xff);
17036         printf ("\n");
17037       }
17038       break;
17039     }
17040
17041   return TRUE;
17042 }
17043
17044 static const char *
17045 get_v850_elf_note_type (enum v850_notes n_type)
17046 {
17047   static char buff[64];
17048
17049   switch (n_type)
17050     {
17051     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
17052     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
17053     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
17054     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
17055     case V850_NOTE_CACHE_INFO: return _("Use of cache");
17056     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
17057     default:
17058       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
17059       return buff;
17060     }
17061 }
17062
17063 static bfd_boolean
17064 print_v850_note (Elf_Internal_Note * pnote)
17065 {
17066   unsigned int val;
17067
17068   if (pnote->descsz != 4)
17069     return FALSE;
17070
17071   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
17072
17073   if (val == 0)
17074     {
17075       printf (_("not set\n"));
17076       return TRUE;
17077     }
17078
17079   switch (pnote->type)
17080     {
17081     case V850_NOTE_ALIGNMENT:
17082       switch (val)
17083         {
17084         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
17085         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
17086         }
17087       break;
17088
17089     case V850_NOTE_DATA_SIZE:
17090       switch (val)
17091         {
17092         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
17093         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
17094         }
17095       break;
17096
17097     case V850_NOTE_FPU_INFO:
17098       switch (val)
17099         {
17100         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
17101         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
17102         }
17103       break;
17104
17105     case V850_NOTE_MMU_INFO:
17106     case V850_NOTE_CACHE_INFO:
17107     case V850_NOTE_SIMD_INFO:
17108       if (val == EF_RH850_SIMD)
17109         {
17110           printf (_("yes\n"));
17111           return TRUE;
17112         }
17113       break;
17114
17115     default:
17116       /* An 'unknown note type' message will already have been displayed.  */
17117       break;
17118     }
17119
17120   printf (_("unknown value: %x\n"), val);
17121   return FALSE;
17122 }
17123
17124 static bfd_boolean
17125 process_netbsd_elf_note (Elf_Internal_Note * pnote)
17126 {
17127   unsigned int version;
17128
17129   switch (pnote->type)
17130     {
17131     case NT_NETBSD_IDENT:
17132       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
17133       if ((version / 10000) % 100)
17134         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
17135                 version, version / 100000000, (version / 1000000) % 100,
17136                 (version / 10000) % 100 > 26 ? "Z" : "",
17137                 'A' + (version / 10000) % 26);
17138       else
17139         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
17140                 version, version / 100000000, (version / 1000000) % 100,
17141                 (version / 100) % 100);
17142       return TRUE;
17143
17144     case NT_NETBSD_MARCH:
17145       printf ("  NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
17146               pnote->descdata);
17147       return TRUE;
17148
17149     default:
17150       printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
17151               pnote->type);
17152       return FALSE;
17153     }
17154 }
17155
17156 static const char *
17157 get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17158 {
17159   switch (e_type)
17160     {
17161     case NT_FREEBSD_THRMISC:
17162       return _("NT_THRMISC (thrmisc structure)");
17163     case NT_FREEBSD_PROCSTAT_PROC:
17164       return _("NT_PROCSTAT_PROC (proc data)");
17165     case NT_FREEBSD_PROCSTAT_FILES:
17166       return _("NT_PROCSTAT_FILES (files data)");
17167     case NT_FREEBSD_PROCSTAT_VMMAP:
17168       return _("NT_PROCSTAT_VMMAP (vmmap data)");
17169     case NT_FREEBSD_PROCSTAT_GROUPS:
17170       return _("NT_PROCSTAT_GROUPS (groups data)");
17171     case NT_FREEBSD_PROCSTAT_UMASK:
17172       return _("NT_PROCSTAT_UMASK (umask data)");
17173     case NT_FREEBSD_PROCSTAT_RLIMIT:
17174       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17175     case NT_FREEBSD_PROCSTAT_OSREL:
17176       return _("NT_PROCSTAT_OSREL (osreldate data)");
17177     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
17178       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17179     case NT_FREEBSD_PROCSTAT_AUXV:
17180       return _("NT_PROCSTAT_AUXV (auxv data)");
17181     case NT_FREEBSD_PTLWPINFO:
17182       return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17183     }
17184   return get_note_type (filedata, e_type);
17185 }
17186
17187 static const char *
17188 get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17189 {
17190   static char buff[64];
17191
17192   if (e_type == NT_NETBSDCORE_PROCINFO)
17193     return _("NetBSD procinfo structure");
17194
17195   /* As of Jan 2002 there are no other machine-independent notes
17196      defined for NetBSD core files.  If the note type is less
17197      than the start of the machine-dependent note types, we don't
17198      understand it.  */
17199
17200   if (e_type < NT_NETBSDCORE_FIRSTMACH)
17201     {
17202       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17203       return buff;
17204     }
17205
17206   switch (filedata->file_header.e_machine)
17207     {
17208     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17209        and PT_GETFPREGS == mach+2.  */
17210
17211     case EM_OLD_ALPHA:
17212     case EM_ALPHA:
17213     case EM_SPARC:
17214     case EM_SPARC32PLUS:
17215     case EM_SPARCV9:
17216       switch (e_type)
17217         {
17218         case NT_NETBSDCORE_FIRSTMACH + 0:
17219           return _("PT_GETREGS (reg structure)");
17220         case NT_NETBSDCORE_FIRSTMACH + 2:
17221           return _("PT_GETFPREGS (fpreg structure)");
17222         default:
17223           break;
17224         }
17225       break;
17226
17227     /* On all other arch's, PT_GETREGS == mach+1 and
17228        PT_GETFPREGS == mach+3.  */
17229     default:
17230       switch (e_type)
17231         {
17232         case NT_NETBSDCORE_FIRSTMACH + 1:
17233           return _("PT_GETREGS (reg structure)");
17234         case NT_NETBSDCORE_FIRSTMACH + 3:
17235           return _("PT_GETFPREGS (fpreg structure)");
17236         default:
17237           break;
17238         }
17239     }
17240
17241   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
17242             e_type - NT_NETBSDCORE_FIRSTMACH);
17243   return buff;
17244 }
17245
17246 static const char *
17247 get_stapsdt_note_type (unsigned e_type)
17248 {
17249   static char buff[64];
17250
17251   switch (e_type)
17252     {
17253     case NT_STAPSDT:
17254       return _("NT_STAPSDT (SystemTap probe descriptors)");
17255
17256     default:
17257       break;
17258     }
17259
17260   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17261   return buff;
17262 }
17263
17264 static bfd_boolean
17265 print_stapsdt_note (Elf_Internal_Note *pnote)
17266 {
17267   int addr_size = is_32bit_elf ? 4 : 8;
17268   char *data = pnote->descdata;
17269   char *data_end = pnote->descdata + pnote->descsz;
17270   bfd_vma pc, base_addr, semaphore;
17271   char *provider, *probe, *arg_fmt;
17272
17273   pc = byte_get ((unsigned char *) data, addr_size);
17274   data += addr_size;
17275   base_addr = byte_get ((unsigned char *) data, addr_size);
17276   data += addr_size;
17277   semaphore = byte_get ((unsigned char *) data, addr_size);
17278   data += addr_size;
17279
17280   provider = data;
17281   data += strlen (data) + 1;
17282   probe = data;
17283   data += strlen (data) + 1;
17284   arg_fmt = data;
17285   data += strlen (data) + 1;
17286
17287   printf (_("    Provider: %s\n"), provider);
17288   printf (_("    Name: %s\n"), probe);
17289   printf (_("    Location: "));
17290   print_vma (pc, FULL_HEX);
17291   printf (_(", Base: "));
17292   print_vma (base_addr, FULL_HEX);
17293   printf (_(", Semaphore: "));
17294   print_vma (semaphore, FULL_HEX);
17295   printf ("\n");
17296   printf (_("    Arguments: %s\n"), arg_fmt);
17297
17298   return data == data_end;
17299 }
17300
17301 static const char *
17302 get_ia64_vms_note_type (unsigned e_type)
17303 {
17304   static char buff[64];
17305
17306   switch (e_type)
17307     {
17308     case NT_VMS_MHD:
17309       return _("NT_VMS_MHD (module header)");
17310     case NT_VMS_LNM:
17311       return _("NT_VMS_LNM (language name)");
17312     case NT_VMS_SRC:
17313       return _("NT_VMS_SRC (source files)");
17314     case NT_VMS_TITLE:
17315       return "NT_VMS_TITLE";
17316     case NT_VMS_EIDC:
17317       return _("NT_VMS_EIDC (consistency check)");
17318     case NT_VMS_FPMODE:
17319       return _("NT_VMS_FPMODE (FP mode)");
17320     case NT_VMS_LINKTIME:
17321       return "NT_VMS_LINKTIME";
17322     case NT_VMS_IMGNAM:
17323       return _("NT_VMS_IMGNAM (image name)");
17324     case NT_VMS_IMGID:
17325       return _("NT_VMS_IMGID (image id)");
17326     case NT_VMS_LINKID:
17327       return _("NT_VMS_LINKID (link id)");
17328     case NT_VMS_IMGBID:
17329       return _("NT_VMS_IMGBID (build id)");
17330     case NT_VMS_GSTNAM:
17331       return _("NT_VMS_GSTNAM (sym table name)");
17332     case NT_VMS_ORIG_DYN:
17333       return "NT_VMS_ORIG_DYN";
17334     case NT_VMS_PATCHTIME:
17335       return "NT_VMS_PATCHTIME";
17336     default:
17337       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17338       return buff;
17339     }
17340 }
17341
17342 static bfd_boolean
17343 print_ia64_vms_note (Elf_Internal_Note * pnote)
17344 {
17345   switch (pnote->type)
17346     {
17347     case NT_VMS_MHD:
17348       if (pnote->descsz > 36)
17349         {
17350           size_t l = strlen (pnote->descdata + 34);
17351           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
17352           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
17353           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
17354           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
17355         }
17356       else
17357         printf (_("    Invalid size\n"));
17358       break;
17359     case NT_VMS_LNM:
17360       printf (_("   Language: %s\n"), pnote->descdata);
17361       break;
17362 #ifdef BFD64
17363     case NT_VMS_FPMODE:
17364       printf (_("   Floating Point mode: "));
17365       printf ("0x%016" BFD_VMA_FMT "x\n",
17366               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
17367       break;
17368     case NT_VMS_LINKTIME:
17369       printf (_("   Link time: "));
17370       print_vms_time
17371         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17372       printf ("\n");
17373       break;
17374     case NT_VMS_PATCHTIME:
17375       printf (_("   Patch time: "));
17376       print_vms_time
17377         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17378       printf ("\n");
17379       break;
17380     case NT_VMS_ORIG_DYN:
17381       printf (_("   Major id: %u,  minor id: %u\n"),
17382               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
17383               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
17384       printf (_("   Last modified  : "));
17385       print_vms_time
17386         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
17387       printf (_("\n   Link flags  : "));
17388       printf ("0x%016" BFD_VMA_FMT "x\n",
17389               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
17390       printf (_("   Header flags: 0x%08x\n"),
17391               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
17392       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
17393       break;
17394 #endif
17395     case NT_VMS_IMGNAM:
17396       printf (_("    Image name: %s\n"), pnote->descdata);
17397       break;
17398     case NT_VMS_GSTNAM:
17399       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
17400       break;
17401     case NT_VMS_IMGID:
17402       printf (_("    Image id: %s\n"), pnote->descdata);
17403       break;
17404     case NT_VMS_LINKID:
17405       printf (_("    Linker id: %s\n"), pnote->descdata);
17406       break;
17407     default:
17408       return FALSE;
17409     }
17410   return TRUE;
17411 }
17412
17413 /* Print the name of the symbol associated with a build attribute
17414    that is attached to address OFFSET.  */
17415
17416 static bfd_boolean
17417 print_symbol_for_build_attribute (Filedata *     filedata,
17418                                   unsigned long  offset,
17419                                   bfd_boolean    is_open_attr)
17420 {
17421   static Filedata *         saved_filedata = NULL;
17422   static char *             strtab;
17423   static unsigned long      strtablen;
17424   static Elf_Internal_Sym * symtab;
17425   static unsigned long      nsyms;
17426   Elf_Internal_Sym *        saved_sym = NULL;
17427   Elf_Internal_Sym *        sym;
17428
17429   if (filedata->section_headers != NULL
17430       && (saved_filedata == NULL || filedata != saved_filedata))
17431     {
17432       Elf_Internal_Shdr * symsec;
17433
17434       /* Load the symbol and string sections.  */
17435       for (symsec = filedata->section_headers;
17436            symsec < filedata->section_headers + filedata->file_header.e_shnum;
17437            symsec ++)
17438         {
17439           if (symsec->sh_type == SHT_SYMTAB)
17440             {
17441               symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
17442
17443               if (symsec->sh_link < filedata->file_header.e_shnum)
17444                 {
17445                   Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
17446
17447                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
17448                                               1, strtab_sec->sh_size,
17449                                               _("string table"));
17450                   strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
17451                 }
17452             }
17453         }
17454       saved_filedata = filedata;
17455     }
17456
17457   if (symtab == NULL || strtab == NULL)
17458     {
17459       printf ("\n");
17460       return FALSE;
17461     }
17462
17463   /* Find a symbol whose value matches offset.  */
17464   for (sym = symtab; sym < symtab + nsyms; sym ++)
17465     if (sym->st_value == offset)
17466       {
17467         if (sym->st_name >= strtablen)
17468           /* Huh ?  This should not happen.  */
17469           continue;
17470
17471         if (strtab[sym->st_name] == 0)
17472           continue;
17473
17474         if (is_open_attr)
17475           {
17476             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17477                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
17478                FUNC symbols entirely.  */
17479             switch (ELF_ST_TYPE (sym->st_info))
17480               {
17481               case STT_FILE:
17482                 saved_sym = sym;
17483                 /* We can stop searching now.  */
17484                 sym = symtab + nsyms;
17485                 continue;
17486
17487               case STT_OBJECT:
17488                 saved_sym = sym;
17489                 continue;
17490
17491               case STT_FUNC:
17492                 /* Ignore function symbols.  */
17493                 continue;
17494
17495               default:
17496                 break;
17497               }
17498
17499             switch (ELF_ST_BIND (sym->st_info))
17500               {
17501               case STB_GLOBAL:
17502                 if (saved_sym == NULL
17503                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
17504                   saved_sym = sym;
17505                 break;
17506
17507               case STB_LOCAL:
17508                 if (saved_sym == NULL)
17509                   saved_sym = sym;
17510                 break;
17511
17512               default:
17513                 break;
17514               }
17515           }
17516         else
17517           {
17518             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
17519               continue;
17520
17521             saved_sym = sym;
17522             break;
17523           }
17524       }
17525
17526   printf (" (%s: %s)\n",
17527           is_open_attr ? _("file") : _("func"),
17528           saved_sym ? strtab + saved_sym->st_name : _("<no symbol found>)"));
17529   return TRUE;
17530 }
17531
17532 static bfd_boolean
17533 print_gnu_build_attribute_description (Elf_Internal_Note *  pnote,
17534                                        Filedata *           filedata)
17535 {
17536   static unsigned long global_offset = 0;
17537   unsigned long        offset;
17538   unsigned int         desc_size = is_32bit_elf ? 4 : 8;
17539   bfd_boolean          is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
17540
17541   if (pnote->descsz == 0)
17542     {
17543       if (is_open_attr)
17544         {
17545           printf (_("    Applies from offset %#lx\n"), global_offset);
17546           return TRUE;
17547         }
17548       else
17549         {
17550           printf (_("    Applies to func at %#lx"), global_offset);
17551           return print_symbol_for_build_attribute (filedata, global_offset, is_open_attr);
17552         }
17553     }
17554
17555   if (pnote->descsz != desc_size)
17556     {
17557       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
17558       printf (_("    <invalid descsz>"));
17559       return FALSE;
17560     }
17561
17562   offset = byte_get ((unsigned char *) pnote->descdata, desc_size);
17563
17564   if (is_open_attr)
17565     {
17566       printf (_("    Applies from offset %#lx"), offset);
17567       global_offset = offset;
17568     }
17569   else
17570     {
17571       printf (_("    Applies to func at %#lx"), offset);
17572     }
17573
17574   return print_symbol_for_build_attribute (filedata, offset, is_open_attr);
17575 }
17576
17577 static bfd_boolean
17578 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
17579 {
17580   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
17581   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
17582   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
17583   char         name_type;
17584   char         name_attribute;
17585   const char * expected_types;
17586   const char * name = pnote->namedata;
17587   const char * text;
17588   signed int   left;
17589
17590   if (name == NULL || pnote->namesz < 2)
17591     {
17592       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17593       print_symbol (-20, _("  <corrupt name>"));
17594       return FALSE;
17595     }
17596
17597   left = 20;
17598
17599   /* Version 2 of the spec adds a "GA" prefix to the name field.  */
17600   if (name[0] == 'G' && name[1] == 'A')
17601     {
17602       printf ("GA");
17603       name += 2;
17604       left -= 2;
17605     }
17606
17607   switch ((name_type = * name))
17608     {
17609     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17610     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17611     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17612     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17613       printf ("%c", * name);
17614       left --;
17615       break;
17616     default:
17617       error (_("unrecognised attribute type in name field: %d\n"), name_type);
17618       print_symbol (-20, _("<unknown name type>"));
17619       return FALSE;
17620     }
17621
17622   ++ name;
17623   text = NULL;
17624
17625   switch ((name_attribute = * name))
17626     {
17627     case GNU_BUILD_ATTRIBUTE_VERSION:
17628       text = _("<version>");
17629       expected_types = string_expected;
17630       ++ name;
17631       break;
17632     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17633       text = _("<stack prot>");
17634       expected_types = "!+*";
17635       ++ name;
17636       break;
17637     case GNU_BUILD_ATTRIBUTE_RELRO:
17638       text = _("<relro>");
17639       expected_types = bool_expected;
17640       ++ name;
17641       break;
17642     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
17643       text = _("<stack size>");
17644       expected_types = number_expected;
17645       ++ name;
17646       break;
17647     case GNU_BUILD_ATTRIBUTE_TOOL:
17648       text = _("<tool>");
17649       expected_types = string_expected;
17650       ++ name;
17651       break;
17652     case GNU_BUILD_ATTRIBUTE_ABI:
17653       text = _("<ABI>");
17654       expected_types = "$*";
17655       ++ name;
17656       break;
17657     case GNU_BUILD_ATTRIBUTE_PIC:
17658       text = _("<PIC>");
17659       expected_types = number_expected;
17660       ++ name;
17661       break;
17662     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
17663       text = _("<short enum>");
17664       expected_types = bool_expected;
17665       ++ name;
17666       break;
17667     default:
17668       if (ISPRINT (* name))
17669         {
17670           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
17671
17672           if (len > left && ! do_wide)
17673             len = left;
17674           printf ("%.*s:", len, name);
17675           left -= len;
17676           name += len;
17677         }
17678       else
17679         {
17680           static char tmpbuf [128];
17681
17682           error (_("unrecognised byte in name field: %d\n"), * name);
17683           sprintf (tmpbuf, _("<unknown:_%d>"), * name);
17684           text = tmpbuf;
17685           name ++;
17686         }
17687       expected_types = "*$!+";
17688       break;
17689     }
17690
17691   if (text)
17692     left -= printf ("%s", text);
17693
17694   if (strchr (expected_types, name_type) == NULL)
17695     warn (_("attribute does not have an expected type (%c)\n"), name_type);
17696
17697   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
17698     {
17699       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17700              (unsigned long) pnote->namesz,
17701              (long) (name - pnote->namedata));
17702       return FALSE;
17703     }
17704
17705   if (left < 1 && ! do_wide)
17706     return TRUE;
17707
17708   switch (name_type)
17709     {
17710     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17711       {
17712         unsigned int        bytes;
17713         unsigned long long  val = 0;
17714         unsigned int        shift = 0;
17715         char *              decoded = NULL;
17716
17717         bytes = pnote->namesz - (name - pnote->namedata);
17718         if (bytes > 0)
17719           /* The -1 is because the name field is always 0 terminated, and we
17720              want to be able to ensure that the shift in the while loop below
17721              will not overflow.  */
17722           -- bytes;
17723
17724         if (bytes > sizeof (val))
17725           {
17726             error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17727                    bytes);
17728             bytes = sizeof (val);
17729           }
17730         /* We do not bother to warn if bytes == 0 as this can
17731            happen with some early versions of the gcc plugin.  */
17732
17733         while (bytes --)
17734           {
17735             unsigned long byte = (* name ++) & 0xff;
17736
17737             val |= byte << shift;
17738             shift += 8;
17739           }
17740
17741         switch (name_attribute)
17742           {
17743           case GNU_BUILD_ATTRIBUTE_PIC:
17744             switch (val)
17745               {
17746               case 0: decoded = "static"; break;
17747               case 1: decoded = "pic"; break;
17748               case 2: decoded = "PIC"; break;
17749               case 3: decoded = "pie"; break;
17750               case 4: decoded = "PIE"; break;
17751               default: break;
17752               }
17753             break;
17754           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17755             switch (val)
17756               {
17757                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
17758               case 0: decoded = "off"; break;
17759               case 1: decoded = "on"; break;
17760               case 2: decoded = "all"; break;
17761               case 3: decoded = "strong"; break;
17762               case 4: decoded = "explicit"; break;
17763               default: break;
17764               }
17765             break;
17766           default:
17767             break;
17768           }
17769
17770         if (decoded != NULL)
17771           {
17772             print_symbol (-left, decoded);
17773             left = 0;
17774           }
17775         else if (val == 0)
17776           {
17777             printf ("0x0");
17778             left -= 3;
17779           }
17780         else
17781           {
17782             if (do_wide)
17783               left -= printf ("0x%llx", val);
17784             else
17785               left -= printf ("0x%-.*llx", left, val);
17786           }
17787       }
17788       break;
17789     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17790       left -= print_symbol (- left, name);
17791       break;
17792     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17793       left -= print_symbol (- left, "true");
17794       break;
17795     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17796       left -= print_symbol (- left, "false");
17797       break;
17798     }
17799
17800   if (do_wide && left > 0)
17801     printf ("%-*s", left, " ");
17802
17803   return TRUE;
17804 }
17805
17806 /* Note that by the ELF standard, the name field is already null byte
17807    terminated, and namesz includes the terminating null byte.
17808    I.E. the value of namesz for the name "FSF" is 4.
17809
17810    If the value of namesz is zero, there is no name present.  */
17811
17812 static bfd_boolean
17813 process_note (Elf_Internal_Note *  pnote,
17814               Filedata *           filedata)
17815 {
17816   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
17817   const char * nt;
17818
17819   if (pnote->namesz == 0)
17820     /* If there is no note name, then use the default set of
17821        note type strings.  */
17822     nt = get_note_type (filedata, pnote->type);
17823
17824   else if (const_strneq (pnote->namedata, "GNU"))
17825     /* GNU-specific object file notes.  */
17826     nt = get_gnu_elf_note_type (pnote->type);
17827
17828   else if (const_strneq (pnote->namedata, "FreeBSD"))
17829     /* FreeBSD-specific core file notes.  */
17830     nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
17831
17832   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
17833     /* NetBSD-specific core file notes.  */
17834     nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
17835
17836   else if (const_strneq (pnote->namedata, "NetBSD"))
17837     /* NetBSD-specific core file notes.  */
17838     return process_netbsd_elf_note (pnote);
17839
17840   else if (strneq (pnote->namedata, "SPU/", 4))
17841     {
17842       /* SPU-specific core file notes.  */
17843       nt = pnote->namedata + 4;
17844       name = "SPU";
17845     }
17846
17847   else if (const_strneq (pnote->namedata, "IPF/VMS"))
17848     /* VMS/ia64-specific file notes.  */
17849     nt = get_ia64_vms_note_type (pnote->type);
17850
17851   else if (const_strneq (pnote->namedata, "stapsdt"))
17852     nt = get_stapsdt_note_type (pnote->type);
17853
17854   else
17855     /* Don't recognize this note name; just use the default set of
17856        note type strings.  */
17857     nt = get_note_type (filedata, pnote->type);
17858
17859   printf ("  ");
17860
17861   if (((const_strneq (pnote->namedata, "GA")
17862         && strchr ("*$!+", pnote->namedata[2]) != NULL)
17863        || strchr ("*$!+", pnote->namedata[0]) != NULL)
17864       && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17865           || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
17866     print_gnu_build_attribute_name (pnote);
17867   else
17868     print_symbol (-20, name);
17869
17870   if (do_wide)
17871     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
17872   else
17873     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
17874
17875   if (const_strneq (pnote->namedata, "IPF/VMS"))
17876     return print_ia64_vms_note (pnote);
17877   else if (const_strneq (pnote->namedata, "GNU"))
17878     return print_gnu_note (filedata, pnote);
17879   else if (const_strneq (pnote->namedata, "stapsdt"))
17880     return print_stapsdt_note (pnote);
17881   else if (const_strneq (pnote->namedata, "CORE"))
17882     return print_core_note (pnote);
17883   else if (((const_strneq (pnote->namedata, "GA")
17884              && strchr ("*$!+", pnote->namedata[2]) != NULL)
17885             || strchr ("*$!+", pnote->namedata[0]) != NULL)
17886            && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17887                || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
17888     return print_gnu_build_attribute_description (pnote, filedata);
17889
17890   if (pnote->descsz)
17891     {
17892       unsigned long i;
17893
17894       printf (_("   description data: "));
17895       for (i = 0; i < pnote->descsz; i++)
17896         printf ("%02x ", pnote->descdata[i]);
17897       if (!do_wide)
17898         printf ("\n");
17899     }
17900
17901   if (do_wide)
17902     printf ("\n");
17903
17904   return TRUE;
17905 }
17906
17907 static bfd_boolean
17908 process_notes_at (Filedata *           filedata,
17909                   Elf_Internal_Shdr *  section,
17910                   bfd_vma              offset,
17911                   bfd_vma              length,
17912                   bfd_vma              align)
17913 {
17914   Elf_External_Note * pnotes;
17915   Elf_External_Note * external;
17916   char *              end;
17917   bfd_boolean         res = TRUE;
17918
17919   if (length <= 0)
17920     return FALSE;
17921
17922   if (section)
17923     {
17924       pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
17925       if (pnotes)
17926         {
17927           if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
17928             return FALSE;
17929         }
17930     }
17931   else
17932     pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
17933                                              _("notes"));
17934
17935   if (pnotes == NULL)
17936     return FALSE;
17937
17938   external = pnotes;
17939
17940   if (section)
17941     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
17942   else
17943     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
17944             (unsigned long) offset, (unsigned long) length);
17945
17946   /* NB: Some note sections may have alignment value of 0 or 1.  gABI
17947      specifies that notes should be aligned to 4 bytes in 32-bit
17948      objects and to 8 bytes in 64-bit objects.  As a Linux extension,
17949      we also support 4 byte alignment in 64-bit objects.  If section
17950      alignment is less than 4, we treate alignment as 4 bytes.   */
17951   if (align < 4)
17952     align = 4;
17953   else if (align != 4 && align != 8)
17954     {
17955       warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
17956             (long) align);
17957       return FALSE;
17958     }
17959
17960   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
17961
17962   end = (char *) pnotes + length;
17963   while ((char *) external < end)
17964     {
17965       Elf_Internal_Note inote;
17966       size_t min_notesz;
17967       char * next;
17968       char * temp = NULL;
17969       size_t data_remaining = end - (char *) external;
17970
17971       if (!is_ia64_vms (filedata))
17972         {
17973           /* PR binutils/15191
17974              Make sure that there is enough data to read.  */
17975           min_notesz = offsetof (Elf_External_Note, name);
17976           if (data_remaining < min_notesz)
17977             {
17978               warn (ngettext ("Corrupt note: only %ld byte remains, "
17979                               "not enough for a full note\n",
17980                               "Corrupt note: only %ld bytes remain, "
17981                               "not enough for a full note\n",
17982                               data_remaining),
17983                     (long) data_remaining);
17984               break;
17985             }
17986           data_remaining -= min_notesz;
17987
17988           inote.type     = BYTE_GET (external->type);
17989           inote.namesz   = BYTE_GET (external->namesz);
17990           inote.namedata = external->name;
17991           inote.descsz   = BYTE_GET (external->descsz);
17992           inote.descdata = ((char *) external
17993                             + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
17994           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
17995           next = ((char *) external
17996                   + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
17997         }
17998       else
17999         {
18000           Elf64_External_VMS_Note *vms_external;
18001
18002           /* PR binutils/15191
18003              Make sure that there is enough data to read.  */
18004           min_notesz = offsetof (Elf64_External_VMS_Note, name);
18005           if (data_remaining < min_notesz)
18006             {
18007               warn (ngettext ("Corrupt note: only %ld byte remains, "
18008                               "not enough for a full note\n",
18009                               "Corrupt note: only %ld bytes remain, "
18010                               "not enough for a full note\n",
18011                               data_remaining),
18012                     (long) data_remaining);
18013               break;
18014             }
18015           data_remaining -= min_notesz;
18016
18017           vms_external = (Elf64_External_VMS_Note *) external;
18018           inote.type     = BYTE_GET (vms_external->type);
18019           inote.namesz   = BYTE_GET (vms_external->namesz);
18020           inote.namedata = vms_external->name;
18021           inote.descsz   = BYTE_GET (vms_external->descsz);
18022           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
18023           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18024           next = inote.descdata + align_power (inote.descsz, 3);
18025         }
18026
18027       /* PR 17531: file: 3443835e.  */
18028       /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
18029       if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
18030           || (size_t) (inote.descdata - inote.namedata) > data_remaining
18031           || (size_t) (next - inote.descdata) < inote.descsz
18032           || ((size_t) (next - inote.descdata)
18033               > data_remaining - (size_t) (inote.descdata - inote.namedata)))
18034         {
18035           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18036                 (unsigned long) ((char *) external - (char *) pnotes));
18037           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18038                 inote.type, inote.namesz, inote.descsz, (int) align);
18039           break;
18040         }
18041
18042       external = (Elf_External_Note *) next;
18043
18044       /* Verify that name is null terminated.  It appears that at least
18045          one version of Linux (RedHat 6.0) generates corefiles that don't
18046          comply with the ELF spec by failing to include the null byte in
18047          namesz.  */
18048       if (inote.namedata[inote.namesz - 1] != '\0')
18049         {
18050           if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
18051             {
18052               temp = (char *) malloc (inote.namesz + 1);
18053               if (temp == NULL)
18054                 {
18055                   error (_("Out of memory allocating space for inote name\n"));
18056                   res = FALSE;
18057                   break;
18058                 }
18059
18060               memcpy (temp, inote.namedata, inote.namesz);
18061               inote.namedata = temp;
18062             }
18063           inote.namedata[inote.namesz] = 0;
18064         }
18065
18066       if (! process_note (& inote, filedata))
18067         res = FALSE;
18068
18069       if (temp != NULL)
18070         {
18071           free (temp);
18072           temp = NULL;
18073         }
18074     }
18075
18076   free (pnotes);
18077
18078   return res;
18079 }
18080
18081 static bfd_boolean
18082 process_corefile_note_segments (Filedata * filedata)
18083 {
18084   Elf_Internal_Phdr * segment;
18085   unsigned int i;
18086   bfd_boolean res = TRUE;
18087
18088   if (! get_program_headers (filedata))
18089     return TRUE;
18090
18091   for (i = 0, segment = filedata->program_headers;
18092        i < filedata->file_header.e_phnum;
18093        i++, segment++)
18094     {
18095       if (segment->p_type == PT_NOTE)
18096         if (! process_notes_at (filedata, NULL,
18097                                 (bfd_vma) segment->p_offset,
18098                                 (bfd_vma) segment->p_filesz,
18099                                 (bfd_vma) segment->p_align))
18100           res = FALSE;
18101     }
18102
18103   return res;
18104 }
18105
18106 static bfd_boolean
18107 process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
18108 {
18109   Elf_External_Note * pnotes;
18110   Elf_External_Note * external;
18111   char * end;
18112   bfd_boolean res = TRUE;
18113
18114   if (length <= 0)
18115     return FALSE;
18116
18117   pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18118                                            _("v850 notes"));
18119   if (pnotes == NULL)
18120     return FALSE;
18121
18122   external = pnotes;
18123   end = (char*) pnotes + length;
18124
18125   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18126           (unsigned long) offset, (unsigned long) length);
18127
18128   while ((char *) external + sizeof (Elf_External_Note) < end)
18129     {
18130       Elf_External_Note * next;
18131       Elf_Internal_Note inote;
18132
18133       inote.type     = BYTE_GET (external->type);
18134       inote.namesz   = BYTE_GET (external->namesz);
18135       inote.namedata = external->name;
18136       inote.descsz   = BYTE_GET (external->descsz);
18137       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
18138       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18139
18140       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
18141         {
18142           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
18143           inote.descdata = inote.namedata;
18144           inote.namesz   = 0;
18145         }
18146
18147       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
18148
18149       if (   ((char *) next > end)
18150           || ((char *) next <  (char *) pnotes))
18151         {
18152           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18153                 (unsigned long) ((char *) external - (char *) pnotes));
18154           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18155                 inote.type, inote.namesz, inote.descsz);
18156           break;
18157         }
18158
18159       external = next;
18160
18161       /* Prevent out-of-bounds indexing.  */
18162       if (   inote.namedata + inote.namesz > end
18163           || inote.namedata + inote.namesz < inote.namedata)
18164         {
18165           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18166                 (unsigned long) ((char *) external - (char *) pnotes));
18167           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18168                 inote.type, inote.namesz, inote.descsz);
18169           break;
18170         }
18171
18172       printf ("  %s: ", get_v850_elf_note_type (inote.type));
18173
18174       if (! print_v850_note (& inote))
18175         {
18176           res = FALSE;
18177           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18178                   inote.namesz, inote.descsz);
18179         }
18180     }
18181
18182   free (pnotes);
18183
18184   return res;
18185 }
18186
18187 static bfd_boolean
18188 process_note_sections (Filedata * filedata)
18189 {
18190   Elf_Internal_Shdr * section;
18191   unsigned long i;
18192   unsigned int n = 0;
18193   bfd_boolean res = TRUE;
18194
18195   for (i = 0, section = filedata->section_headers;
18196        i < filedata->file_header.e_shnum && section != NULL;
18197        i++, section++)
18198     {
18199       if (section->sh_type == SHT_NOTE)
18200         {
18201           if (! process_notes_at (filedata, section,
18202                                   (bfd_vma) section->sh_offset,
18203                                   (bfd_vma) section->sh_size,
18204                                   (bfd_vma) section->sh_addralign))
18205             res = FALSE;
18206           n++;
18207         }
18208
18209       if ((   filedata->file_header.e_machine == EM_V800
18210            || filedata->file_header.e_machine == EM_V850
18211            || filedata->file_header.e_machine == EM_CYGNUS_V850)
18212           && section->sh_type == SHT_RENESAS_INFO)
18213         {
18214           if (! process_v850_notes (filedata,
18215                                     (bfd_vma) section->sh_offset,
18216                                     (bfd_vma) section->sh_size))
18217             res = FALSE;
18218           n++;
18219         }
18220     }
18221
18222   if (n == 0)
18223     /* Try processing NOTE segments instead.  */
18224     return process_corefile_note_segments (filedata);
18225
18226   return res;
18227 }
18228
18229 static bfd_boolean
18230 process_notes (Filedata * filedata)
18231 {
18232   /* If we have not been asked to display the notes then do nothing.  */
18233   if (! do_notes)
18234     return TRUE;
18235
18236   if (filedata->file_header.e_type != ET_CORE)
18237     return process_note_sections (filedata);
18238
18239   /* No program headers means no NOTE segment.  */
18240   if (filedata->file_header.e_phnum > 0)
18241     return process_corefile_note_segments (filedata);
18242
18243   printf (_("No note segments present in the core file.\n"));
18244   return TRUE;
18245 }
18246
18247 static unsigned char *
18248 display_public_gnu_attributes (unsigned char * start,
18249                                const unsigned char * const end)
18250 {
18251   printf (_("  Unknown GNU attribute: %s\n"), start);
18252
18253   start += strnlen ((char *) start, end - start);
18254   display_raw_attribute (start, end);
18255
18256   return (unsigned char *) end;
18257 }
18258
18259 static unsigned char *
18260 display_generic_attribute (unsigned char * start,
18261                            unsigned int tag,
18262                            const unsigned char * const end)
18263 {
18264   if (tag == 0)
18265     return (unsigned char *) end;
18266
18267   return display_tag_value (tag, start, end);
18268 }
18269
18270 static bfd_boolean
18271 process_arch_specific (Filedata * filedata)
18272 {
18273   if (! do_arch)
18274     return TRUE;
18275
18276   switch (filedata->file_header.e_machine)
18277     {
18278     case EM_ARC:
18279     case EM_ARC_COMPACT:
18280     case EM_ARC_COMPACT2:
18281       return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
18282                                  display_arc_attribute,
18283                                  display_generic_attribute);
18284     case EM_ARM:
18285       return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
18286                                  display_arm_attribute,
18287                                  display_generic_attribute);
18288
18289     case EM_MIPS:
18290     case EM_MIPS_RS3_LE:
18291       return process_mips_specific (filedata);
18292
18293     case EM_MSP430:
18294      return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
18295                                 display_msp430x_attribute,
18296                                 display_generic_attribute);
18297
18298     case EM_NDS32:
18299       return process_nds32_specific (filedata);
18300
18301     case EM_PPC:
18302     case EM_PPC64:
18303       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18304                                  display_power_gnu_attribute);
18305
18306     case EM_S390:
18307     case EM_S390_OLD:
18308       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18309                                  display_s390_gnu_attribute);
18310
18311     case EM_SPARC:
18312     case EM_SPARC32PLUS:
18313     case EM_SPARCV9:
18314       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18315                                  display_sparc_gnu_attribute);
18316
18317     case EM_TI_C6000:
18318       return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
18319                                  display_tic6x_attribute,
18320                                  display_generic_attribute);
18321
18322     default:
18323       return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
18324                                  display_public_gnu_attributes,
18325                                  display_generic_attribute);
18326     }
18327 }
18328
18329 static bfd_boolean
18330 get_file_header (Filedata * filedata)
18331 {
18332   /* Read in the identity array.  */
18333   if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
18334     return FALSE;
18335
18336   /* Determine how to read the rest of the header.  */
18337   switch (filedata->file_header.e_ident[EI_DATA])
18338     {
18339     default:
18340     case ELFDATANONE:
18341     case ELFDATA2LSB:
18342       byte_get = byte_get_little_endian;
18343       byte_put = byte_put_little_endian;
18344       break;
18345     case ELFDATA2MSB:
18346       byte_get = byte_get_big_endian;
18347       byte_put = byte_put_big_endian;
18348       break;
18349     }
18350
18351   /* For now we only support 32 bit and 64 bit ELF files.  */
18352   is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
18353
18354   /* Read in the rest of the header.  */
18355   if (is_32bit_elf)
18356     {
18357       Elf32_External_Ehdr ehdr32;
18358
18359       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
18360         return FALSE;
18361
18362       filedata->file_header.e_type      = BYTE_GET (ehdr32.e_type);
18363       filedata->file_header.e_machine   = BYTE_GET (ehdr32.e_machine);
18364       filedata->file_header.e_version   = BYTE_GET (ehdr32.e_version);
18365       filedata->file_header.e_entry     = BYTE_GET (ehdr32.e_entry);
18366       filedata->file_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
18367       filedata->file_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
18368       filedata->file_header.e_flags     = BYTE_GET (ehdr32.e_flags);
18369       filedata->file_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
18370       filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
18371       filedata->file_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
18372       filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
18373       filedata->file_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
18374       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
18375     }
18376   else
18377     {
18378       Elf64_External_Ehdr ehdr64;
18379
18380       /* If we have been compiled with sizeof (bfd_vma) == 4, then
18381          we will not be able to cope with the 64bit data found in
18382          64 ELF files.  Detect this now and abort before we start
18383          overwriting things.  */
18384       if (sizeof (bfd_vma) < 8)
18385         {
18386           error (_("This instance of readelf has been built without support for a\n\
18387 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18388           return FALSE;
18389         }
18390
18391       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
18392         return FALSE;
18393
18394       filedata->file_header.e_type      = BYTE_GET (ehdr64.e_type);
18395       filedata->file_header.e_machine   = BYTE_GET (ehdr64.e_machine);
18396       filedata->file_header.e_version   = BYTE_GET (ehdr64.e_version);
18397       filedata->file_header.e_entry     = BYTE_GET (ehdr64.e_entry);
18398       filedata->file_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
18399       filedata->file_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
18400       filedata->file_header.e_flags     = BYTE_GET (ehdr64.e_flags);
18401       filedata->file_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
18402       filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
18403       filedata->file_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
18404       filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
18405       filedata->file_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
18406       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
18407     }
18408
18409   if (filedata->file_header.e_shoff)
18410     {
18411       /* There may be some extensions in the first section header.  Don't
18412          bomb if we can't read it.  */
18413       if (is_32bit_elf)
18414         get_32bit_section_headers (filedata, TRUE);
18415       else
18416         get_64bit_section_headers (filedata, TRUE);
18417     }
18418
18419   return TRUE;
18420 }
18421
18422 static void
18423 close_file (Filedata * filedata)
18424 {
18425   if (filedata)
18426     {
18427       if (filedata->handle)
18428         fclose (filedata->handle);
18429       free (filedata);
18430     }
18431 }
18432
18433 void
18434 close_debug_file (void * data)
18435 {
18436   close_file ((Filedata *) data);
18437 }
18438
18439 static Filedata *
18440 open_file (const char * pathname)
18441 {
18442   struct stat  statbuf;
18443   Filedata *   filedata = NULL;
18444
18445   if (stat (pathname, & statbuf) < 0
18446       || ! S_ISREG (statbuf.st_mode))
18447     goto fail;
18448
18449   filedata = calloc (1, sizeof * filedata);
18450   if (filedata == NULL)
18451     goto fail;
18452
18453   filedata->handle = fopen (pathname, "rb");
18454   if (filedata->handle == NULL)
18455     goto fail;
18456
18457   filedata->file_size = (bfd_size_type) statbuf.st_size;
18458   filedata->file_name = pathname;
18459
18460   if (! get_file_header (filedata))
18461     goto fail;
18462
18463   if (filedata->file_header.e_shoff)
18464     {
18465       bfd_boolean res;
18466
18467       /* Read the section headers again, this time for real.  */
18468       if (is_32bit_elf)
18469         res = get_32bit_section_headers (filedata, FALSE);
18470       else
18471         res = get_64bit_section_headers (filedata, FALSE);
18472
18473       if (!res)
18474         goto fail;
18475     }
18476
18477   return filedata;
18478
18479  fail:
18480   if (filedata)
18481     {
18482       if (filedata->handle)
18483         fclose (filedata->handle);
18484       free (filedata);
18485     }
18486   return NULL;
18487 }
18488
18489 void *
18490 open_debug_file (const char * pathname)
18491 {
18492   return open_file (pathname);
18493 }
18494
18495 /* Process one ELF object file according to the command line options.
18496    This file may actually be stored in an archive.  The file is
18497    positioned at the start of the ELF object.  Returns TRUE if no
18498    problems were encountered, FALSE otherwise.  */
18499
18500 static bfd_boolean
18501 process_object (Filedata * filedata)
18502 {
18503   Filedata * separates;
18504   unsigned int i;
18505   bfd_boolean res = TRUE;
18506
18507   if (! get_file_header (filedata))
18508     {
18509       error (_("%s: Failed to read file header\n"), filedata->file_name);
18510       return FALSE;
18511     }
18512
18513   /* Initialise per file variables.  */
18514   for (i = ARRAY_SIZE (version_info); i--;)
18515     version_info[i] = 0;
18516
18517   for (i = ARRAY_SIZE (dynamic_info); i--;)
18518     dynamic_info[i] = 0;
18519   dynamic_info_DT_GNU_HASH = 0;
18520
18521   /* Process the file.  */
18522   if (show_name)
18523     printf (_("\nFile: %s\n"), filedata->file_name);
18524
18525   /* Initialise the dump_sects array from the cmdline_dump_sects array.
18526      Note we do this even if cmdline_dump_sects is empty because we
18527      must make sure that the dump_sets array is zeroed out before each
18528      object file is processed.  */
18529   if (filedata->num_dump_sects > cmdline.num_dump_sects)
18530     memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
18531
18532   if (cmdline.num_dump_sects > 0)
18533     {
18534       if (filedata->num_dump_sects == 0)
18535         /* A sneaky way of allocating the dump_sects array.  */
18536         request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
18537
18538       assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
18539       memcpy (filedata->dump_sects, cmdline.dump_sects,
18540               cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
18541     }
18542
18543   if (! process_file_header (filedata))
18544     return FALSE;
18545
18546   if (! process_section_headers (filedata))
18547     {
18548       /* Without loaded section headers we cannot process lots of things.  */
18549       do_unwind = do_version = do_dump = do_arch = FALSE;
18550
18551       if (! do_using_dynamic)
18552         do_syms = do_dyn_syms = do_reloc = FALSE;
18553     }
18554
18555   if (! process_section_groups (filedata))
18556     /* Without loaded section groups we cannot process unwind.  */
18557     do_unwind = FALSE;
18558
18559   if (process_program_headers (filedata))
18560     process_dynamic_section (filedata);
18561   else
18562     res = FALSE;
18563
18564   if (! process_relocs (filedata))
18565     res = FALSE;
18566
18567   if (! process_unwind (filedata))
18568     res = FALSE;
18569
18570   if (! process_symbol_table (filedata))
18571     res = FALSE;
18572
18573   if (! process_syminfo (filedata))
18574     res = FALSE;
18575
18576   if (! process_version_sections (filedata))
18577     res = FALSE;
18578
18579   if (filedata->file_header.e_shstrndx != SHN_UNDEF)
18580     separates = load_separate_debug_file (filedata, filedata->file_name);
18581   else
18582     separates = NULL;
18583
18584   if (! process_section_contents (filedata))
18585     res = FALSE;
18586
18587   if (separates)
18588     {
18589       if (! process_section_headers (separates))
18590         res = FALSE;
18591       else if (! process_section_contents (separates))
18592         res = FALSE;
18593     }
18594
18595   if (! process_notes (filedata))
18596     res = FALSE;
18597
18598   if (! process_gnu_liblist (filedata))
18599     res = FALSE;
18600
18601   if (! process_arch_specific (filedata))
18602     res = FALSE;
18603
18604   free (filedata->program_headers);
18605   filedata->program_headers = NULL;
18606
18607   free (filedata->section_headers);
18608   filedata->section_headers = NULL;
18609
18610   free (filedata->string_table);
18611   filedata->string_table = NULL;
18612   filedata->string_table_length = 0;
18613
18614   if (dynamic_strings)
18615     {
18616       free (dynamic_strings);
18617       dynamic_strings = NULL;
18618       dynamic_strings_length = 0;
18619     }
18620
18621   if (dynamic_symbols)
18622     {
18623       free (dynamic_symbols);
18624       dynamic_symbols = NULL;
18625       num_dynamic_syms = 0;
18626     }
18627
18628   if (dynamic_syminfo)
18629     {
18630       free (dynamic_syminfo);
18631       dynamic_syminfo = NULL;
18632     }
18633
18634   if (dynamic_section)
18635     {
18636       free (dynamic_section);
18637       dynamic_section = NULL;
18638     }
18639
18640   if (section_headers_groups)
18641     {
18642       free (section_headers_groups);
18643       section_headers_groups = NULL;
18644     }
18645
18646   if (section_groups)
18647     {
18648       struct group_list * g;
18649       struct group_list * next;
18650
18651       for (i = 0; i < group_count; i++)
18652         {
18653           for (g = section_groups [i].root; g != NULL; g = next)
18654             {
18655               next = g->next;
18656               free (g);
18657             }
18658         }
18659
18660       free (section_groups);
18661       section_groups = NULL;
18662     }
18663
18664   free_debug_memory ();
18665
18666   return res;
18667 }
18668
18669 /* Process an ELF archive.
18670    On entry the file is positioned just after the ARMAG string.
18671    Returns TRUE upon success, FALSE otherwise.  */
18672
18673 static bfd_boolean
18674 process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
18675 {
18676   struct archive_info arch;
18677   struct archive_info nested_arch;
18678   size_t got;
18679   bfd_boolean ret = TRUE;
18680
18681   show_name = TRUE;
18682
18683   /* The ARCH structure is used to hold information about this archive.  */
18684   arch.file_name = NULL;
18685   arch.file = NULL;
18686   arch.index_array = NULL;
18687   arch.sym_table = NULL;
18688   arch.longnames = NULL;
18689
18690   /* The NESTED_ARCH structure is used as a single-item cache of information
18691      about a nested archive (when members of a thin archive reside within
18692      another regular archive file).  */
18693   nested_arch.file_name = NULL;
18694   nested_arch.file = NULL;
18695   nested_arch.index_array = NULL;
18696   nested_arch.sym_table = NULL;
18697   nested_arch.longnames = NULL;
18698
18699   if (setup_archive (&arch, filedata->file_name, filedata->handle,
18700                      is_thin_archive, do_archive_index) != 0)
18701     {
18702       ret = FALSE;
18703       goto out;
18704     }
18705
18706   if (do_archive_index)
18707     {
18708       if (arch.sym_table == NULL)
18709         error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
18710       else
18711         {
18712           unsigned long i, l;
18713           unsigned long current_pos;
18714
18715           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18716                   filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
18717
18718           current_pos = ftell (filedata->handle);
18719
18720           for (i = l = 0; i < arch.index_num; i++)
18721             {
18722               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
18723                 {
18724                   char * member_name;
18725
18726                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
18727
18728                   if (member_name != NULL)
18729                     {
18730                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
18731
18732                       if (qualified_name != NULL)
18733                         {
18734                           printf (_("Contents of binary %s at offset "), qualified_name);
18735                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
18736                           putchar ('\n');
18737                           free (qualified_name);
18738                         }
18739                     }
18740                 }
18741
18742               if (l >= arch.sym_size)
18743                 {
18744                   error (_("%s: end of the symbol table reached before the end of the index\n"),
18745                          filedata->file_name);
18746                   ret = FALSE;
18747                   break;
18748                 }
18749               /* PR 17531: file: 0b6630b2.  */
18750               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
18751               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
18752             }
18753
18754           if (arch.uses_64bit_indicies)
18755             l = (l + 7) & ~ 7;
18756           else
18757             l += l & 1;
18758
18759           if (l < arch.sym_size)
18760             {
18761               error (ngettext ("%s: %ld byte remains in the symbol table, "
18762                                "but without corresponding entries in "
18763                                "the index table\n",
18764                                "%s: %ld bytes remain in the symbol table, "
18765                                "but without corresponding entries in "
18766                                "the index table\n",
18767                                arch.sym_size - l),
18768                      filedata->file_name, arch.sym_size - l);
18769               ret = FALSE;
18770             }
18771
18772           if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
18773             {
18774               error (_("%s: failed to seek back to start of object files in the archive\n"),
18775                      filedata->file_name);
18776               ret = FALSE;
18777               goto out;
18778             }
18779         }
18780
18781       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
18782           && !do_segments && !do_header && !do_dump && !do_version
18783           && !do_histogram && !do_debugging && !do_arch && !do_notes
18784           && !do_section_groups && !do_dyn_syms)
18785         {
18786           ret = TRUE; /* Archive index only.  */
18787           goto out;
18788         }
18789     }
18790
18791   while (1)
18792     {
18793       char * name;
18794       size_t namelen;
18795       char * qualified_name;
18796
18797       /* Read the next archive header.  */
18798       if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
18799         {
18800           error (_("%s: failed to seek to next archive header\n"), filedata->file_name);
18801           return FALSE;
18802         }
18803       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
18804       if (got != sizeof arch.arhdr)
18805         {
18806           if (got == 0)
18807             break;
18808           error (_("%s: failed to read archive header\n"), filedata->file_name);
18809           ret = FALSE;
18810           break;
18811         }
18812       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
18813         {
18814           error (_("%s: did not find a valid archive header\n"), arch.file_name);
18815           ret = FALSE;
18816           break;
18817         }
18818
18819       arch.next_arhdr_offset += sizeof arch.arhdr;
18820
18821       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
18822       if (archive_file_size & 01)
18823         ++archive_file_size;
18824
18825       name = get_archive_member_name (&arch, &nested_arch);
18826       if (name == NULL)
18827         {
18828           error (_("%s: bad archive file name\n"), filedata->file_name);
18829           ret = FALSE;
18830           break;
18831         }
18832       namelen = strlen (name);
18833
18834       qualified_name = make_qualified_name (&arch, &nested_arch, name);
18835       if (qualified_name == NULL)
18836         {
18837           error (_("%s: bad archive file name\n"), filedata->file_name);
18838           ret = FALSE;
18839           break;
18840         }
18841
18842       if (is_thin_archive && arch.nested_member_origin == 0)
18843         {
18844           /* This is a proxy for an external member of a thin archive.  */
18845           Filedata * member_filedata;
18846           char * member_file_name = adjust_relative_path
18847             (filedata->file_name, name, namelen);
18848
18849           if (member_file_name == NULL)
18850             {
18851               ret = FALSE;
18852               break;
18853             }
18854
18855           member_filedata = open_file (member_file_name);
18856           if (member_filedata == NULL)
18857             {
18858               error (_("Input file '%s' is not readable.\n"), member_file_name);
18859               free (member_file_name);
18860               ret = FALSE;
18861               break;
18862             }
18863
18864           archive_file_offset = arch.nested_member_origin;
18865           member_filedata->file_name = qualified_name;
18866
18867           if (! process_object (member_filedata))
18868             ret = FALSE;
18869
18870           close_file (member_filedata);
18871           free (member_file_name);
18872         }
18873       else if (is_thin_archive)
18874         {
18875           Filedata thin_filedata;
18876
18877           memset (&thin_filedata, 0, sizeof (thin_filedata));
18878
18879           /* PR 15140: Allow for corrupt thin archives.  */
18880           if (nested_arch.file == NULL)
18881             {
18882               error (_("%s: contains corrupt thin archive: %s\n"),
18883                      filedata->file_name, name);
18884               ret = FALSE;
18885               break;
18886             }
18887
18888           /* This is a proxy for a member of a nested archive.  */
18889           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
18890
18891           /* The nested archive file will have been opened and setup by
18892              get_archive_member_name.  */
18893           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
18894             {
18895               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
18896               ret = FALSE;
18897               break;
18898             }
18899
18900           thin_filedata.handle = nested_arch.file;
18901           thin_filedata.file_name = qualified_name;
18902
18903           if (! process_object (& thin_filedata))
18904             ret = FALSE;
18905         }
18906       else
18907         {
18908           archive_file_offset = arch.next_arhdr_offset;
18909           arch.next_arhdr_offset += archive_file_size;
18910
18911           filedata->file_name = qualified_name;
18912           if (! process_object (filedata))
18913             ret = FALSE;
18914         }
18915
18916       if (filedata->dump_sects != NULL)
18917         {
18918           free (filedata->dump_sects);
18919           filedata->dump_sects = NULL;
18920           filedata->num_dump_sects = 0;
18921         }
18922
18923       free (qualified_name);
18924     }
18925
18926  out:
18927   if (nested_arch.file != NULL)
18928     fclose (nested_arch.file);
18929   release_archive (&nested_arch);
18930   release_archive (&arch);
18931
18932   return ret;
18933 }
18934
18935 static bfd_boolean
18936 process_file (char * file_name)
18937 {
18938   Filedata * filedata = NULL;
18939   struct stat statbuf;
18940   char armag[SARMAG];
18941   bfd_boolean ret = TRUE;
18942
18943   if (stat (file_name, &statbuf) < 0)
18944     {
18945       if (errno == ENOENT)
18946         error (_("'%s': No such file\n"), file_name);
18947       else
18948         error (_("Could not locate '%s'.  System error message: %s\n"),
18949                file_name, strerror (errno));
18950       return FALSE;
18951     }
18952
18953   if (! S_ISREG (statbuf.st_mode))
18954     {
18955       error (_("'%s' is not an ordinary file\n"), file_name);
18956       return FALSE;
18957     }
18958
18959   filedata = calloc (1, sizeof * filedata);
18960   if (filedata == NULL)
18961     {
18962       error (_("Out of memory allocating file data structure\n"));
18963       return FALSE;
18964     }
18965
18966   filedata->file_name = file_name;
18967   filedata->handle = fopen (file_name, "rb");
18968   if (filedata->handle == NULL)
18969     {
18970       error (_("Input file '%s' is not readable.\n"), file_name);
18971       free (filedata);
18972       return FALSE;
18973     }
18974
18975   if (fread (armag, SARMAG, 1, filedata->handle) != 1)
18976     {
18977       error (_("%s: Failed to read file's magic number\n"), file_name);
18978       fclose (filedata->handle);
18979       free (filedata);
18980       return FALSE;
18981     }
18982
18983   filedata->file_size = (bfd_size_type) statbuf.st_size;
18984
18985   if (memcmp (armag, ARMAG, SARMAG) == 0)
18986     {
18987       if (! process_archive (filedata, FALSE))
18988         ret = FALSE;
18989     }
18990   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
18991     {
18992       if ( ! process_archive (filedata, TRUE))
18993         ret = FALSE;
18994     }
18995   else
18996     {
18997       if (do_archive_index)
18998         error (_("File %s is not an archive so its index cannot be displayed.\n"),
18999                file_name);
19000
19001       rewind (filedata->handle);
19002       archive_file_size = archive_file_offset = 0;
19003
19004       if (! process_object (filedata))
19005         ret = FALSE;
19006     }
19007
19008   fclose (filedata->handle);
19009   free (filedata);
19010
19011   return ret;
19012 }
19013
19014 #ifdef SUPPORT_DISASSEMBLY
19015 /* Needed by the i386 disassembler.  For extra credit, someone could
19016    fix this so that we insert symbolic addresses here, esp for GOT/PLT
19017    symbols.  */
19018
19019 void
19020 print_address (unsigned int addr, FILE * outfile)
19021 {
19022   fprintf (outfile,"0x%8.8x", addr);
19023 }
19024
19025 /* Needed by the i386 disassembler.  */
19026
19027 void
19028 db_task_printsym (unsigned int addr)
19029 {
19030   print_address (addr, stderr);
19031 }
19032 #endif
19033
19034 int
19035 main (int argc, char ** argv)
19036 {
19037   int err;
19038
19039 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19040   setlocale (LC_MESSAGES, "");
19041 #endif
19042 #if defined (HAVE_SETLOCALE)
19043   setlocale (LC_CTYPE, "");
19044 #endif
19045   bindtextdomain (PACKAGE, LOCALEDIR);
19046   textdomain (PACKAGE);
19047
19048   expandargv (&argc, &argv);
19049
19050   cmdline.file_name = "<cmdline>";
19051   parse_args (& cmdline, argc, argv);
19052
19053   if (optind < (argc - 1))
19054     show_name = TRUE;
19055   else if (optind >= argc)
19056     {
19057       warn (_("Nothing to do.\n"));
19058       usage (stderr);
19059     }
19060
19061   err = FALSE;
19062   while (optind < argc)
19063     if (! process_file (argv[optind++]))
19064       err = TRUE;
19065
19066   if (cmdline.dump_sects != NULL)
19067     free (cmdline.dump_sects);
19068
19069   return err ? EXIT_FAILURE : EXIT_SUCCESS;
19070 }