binutils/readelf.c

   1 /* readelf.c -- display contents of an ELF format file
   2    Copyright (C) 1998-2018 Free Software Foundation, Inc.
   3
   4    Originally developed by Eric Youngdale <eric@andante.jic.com>
   5    Modifications by Nick Clifton <nickc@redhat.com>
   6
   7    This file is part of GNU Binutils.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  22    02110-1301, USA.  */
  23 \f
  24 /* The difference between readelf and objdump:
  25
  26   Both programs are capable of displaying the contents of ELF format files,
  27   so why does the binutils project have two file dumpers ?
  28
  29   The reason is that objdump sees an ELF file through a BFD filter of the
  30   world; if BFD has a bug where, say, it disagrees about a machine constant
  31   in e_flags, then the odds are good that it will remain internally
  32   consistent.  The linker sees it the BFD way, objdump sees it the BFD way,
  33   GAS sees it the BFD way.  There was need for a tool to go find out what
  34   the file actually says.
  35
  36   This is why the readelf program does not link against the BFD library - it
  37   exists as an independent program to help verify the correct working of BFD.
  38
  39   There is also the case that readelf can provide more information about an
  40   ELF file than is provided by objdump.  In particular it can display DWARF
  41   debugging information which (at the moment) objdump cannot.  */
  42 \f
  43 #include "sysdep.h"
  44 #include <assert.h>
  45 #include <time.h>
  46 #include <zlib.h>
  47 #ifdef HAVE_WCHAR_H
  48 #include <wchar.h>
  49 #endif
  50
  51 #if __GNUC__ >= 2
  52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
  53    as this will allow us to read in and parse 64bit and 32bit ELF files.
  54    Only do this if we believe that the compiler can support a 64 bit
  55    data type.  For now we only rely on GCC being able to do this.  */
  56 #define BFD64
  57 #endif
  58
  59 #include "bfd.h"
  60 #include "bucomm.h"
  61 #include "elfcomm.h"
  62 #include "dwarf.h"
  63
  64 #include "elf/common.h"
  65 #include "elf/external.h"
  66 #include "elf/internal.h"
  67
  68
  69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
  70    we can obtain the H8 reloc numbers.  We need these for the
  71    get_reloc_size() function.  We include h8.h again after defining
  72    RELOC_MACROS_GEN_FUNC so that we get the naming function as well.  */
  73
  74 #include "elf/h8.h"
  75 #undef _ELF_H8_H
  76
  77 /* Undo the effects of #including reloc-macros.h.  */
  78
  79 #undef START_RELOC_NUMBERS
  80 #undef RELOC_NUMBER
  81 #undef FAKE_RELOC
  82 #undef EMPTY_RELOC
  83 #undef END_RELOC_NUMBERS
  84 #undef _RELOC_MACROS_H
  85
  86 /* The following headers use the elf/reloc-macros.h file to
  87    automatically generate relocation recognition functions
  88    such as elf_mips_reloc_type()  */
  89
  90 #define RELOC_MACROS_GEN_FUNC
  91
  92 #include "elf/aarch64.h"
  93 #include "elf/alpha.h"
  94 #include "elf/arc.h"
  95 #include "elf/arm.h"
  96 #include "elf/avr.h"
  97 #include "elf/bfin.h"
  98 #include "elf/cr16.h"
  99 #include "elf/cris.h"
 100 #include "elf/crx.h"
 101 #include "elf/d10v.h"
 102 #include "elf/d30v.h"
 103 #include "elf/dlx.h"
 104 #include "elf/epiphany.h"
 105 #include "elf/fr30.h"
 106 #include "elf/frv.h"
 107 #include "elf/ft32.h"
 108 #include "elf/h8.h"
 109 #include "elf/hppa.h"
 110 #include "elf/i386.h"
 111 #include "elf/i370.h"
 112 #include "elf/i860.h"
 113 #include "elf/i960.h"
 114 #include "elf/ia64.h"
 115 #include "elf/ip2k.h"
 116 #include "elf/lm32.h"
 117 #include "elf/iq2000.h"
 118 #include "elf/m32c.h"
 119 #include "elf/m32r.h"
 120 #include "elf/m68k.h"
 121 #include "elf/m68hc11.h"
 122 #include "elf/mcore.h"
 123 #include "elf/mep.h"
 124 #include "elf/metag.h"
 125 #include "elf/microblaze.h"
 126 #include "elf/mips.h"
 127 #include "elf/mmix.h"
 128 #include "elf/mn10200.h"
 129 #include "elf/mn10300.h"
 130 #include "elf/moxie.h"
 131 #include "elf/mt.h"
 132 #include "elf/msp430.h"
 133 #include "elf/nds32.h"
 134 #include "elf/nios2.h"
 135 #include "elf/or1k.h"
 136 #include "elf/pj.h"
 137 #include "elf/ppc.h"
 138 #include "elf/ppc64.h"
 139 #include "elf/pru.h"
 140 #include "elf/riscv.h"
 141 #include "elf/rl78.h"
 142 #include "elf/rx.h"
 143 #include "elf/s390.h"
 144 #include "elf/score.h"
 145 #include "elf/sh.h"
 146 #include "elf/sparc.h"
 147 #include "elf/spu.h"
 148 #include "elf/tic6x.h"
 149 #include "elf/tilegx.h"
 150 #include "elf/tilepro.h"
 151 #include "elf/v850.h"
 152 #include "elf/vax.h"
 153 #include "elf/visium.h"
 154 #include "elf/wasm32.h"
 155 #include "elf/x86-64.h"
 156 #include "elf/xc16x.h"
 157 #include "elf/xgate.h"
 158 #include "elf/xstormy16.h"
 159 #include "elf/xtensa.h"
 160
 161 #include "getopt.h"
 162 #include "libiberty.h"
 163 #include "safe-ctype.h"
 164 #include "filenames.h"
 165
 166 #ifndef offsetof
 167 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
 168 #endif
 169
 170 typedef struct elf_section_list
 171 {
 172   Elf_Internal_Shdr *        hdr;
 173   struct elf_section_list *  next;
 174 } elf_section_list;
 175
 176 /* Flag bits indicating particular types of dump.  */
 177 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
 178 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
 179 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
 180 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
 181 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
 182
 183 typedef unsigned char dump_type;
 184
 185 /* A linked list of the section names for which dumps were requested.  */
 186 struct dump_list_entry
 187 {
 188   char *                    name;
 189   dump_type                 type;
 190   struct dump_list_entry *  next;
 191 };
 192
 193 typedef struct filedata
 194 {
 195   const char *         file_name;
 196   FILE *               handle;
 197   bfd_size_type        file_size;
 198   Elf_Internal_Ehdr    file_header;
 199   Elf_Internal_Shdr *  section_headers;
 200   Elf_Internal_Phdr *  program_headers;
 201   char *               string_table;
 202   unsigned long        string_table_length;
 203   /* A dynamic array of flags indicating for which sections a dump of
 204      some kind has been requested.  It is reset on a per-object file
 205      basis and then initialised from the cmdline_dump_sects array,
 206      the results of interpreting the -w switch, and the
 207      dump_sects_byname list.  */
 208   dump_type *          dump_sects;
 209   unsigned int         num_dump_sects;
 210 } Filedata;
 211
 212 char * program_name = "readelf";
 213
 214 static unsigned long archive_file_offset;
 215 static unsigned long archive_file_size;
 216 static unsigned long dynamic_addr;
 217 static bfd_size_type dynamic_size;
 218 static size_t dynamic_nent;
 219 static char * dynamic_strings;
 220 static unsigned long dynamic_strings_length;
 221 static unsigned long num_dynamic_syms;
 222 static Elf_Internal_Sym * dynamic_symbols;
 223 static Elf_Internal_Syminfo * dynamic_syminfo;
 224 static unsigned long dynamic_syminfo_offset;
 225 static unsigned int dynamic_syminfo_nent;
 226 static char program_interpreter[PATH_MAX];
 227 static bfd_vma dynamic_info[DT_ENCODING];
 228 static bfd_vma dynamic_info_DT_GNU_HASH;
 229 static bfd_vma version_info[16];
 230 static Elf_Internal_Dyn *  dynamic_section;
 231 static elf_section_list * symtab_shndx_list;
 232 static bfd_boolean show_name = FALSE;
 233 static bfd_boolean do_dynamic = FALSE;
 234 static bfd_boolean do_syms = FALSE;
 235 static bfd_boolean do_dyn_syms = FALSE;
 236 static bfd_boolean do_reloc = FALSE;
 237 static bfd_boolean do_sections = FALSE;
 238 static bfd_boolean do_section_groups = FALSE;
 239 static bfd_boolean do_section_details = FALSE;
 240 static bfd_boolean do_segments = FALSE;
 241 static bfd_boolean do_unwind = FALSE;
 242 static bfd_boolean do_using_dynamic = FALSE;
 243 static bfd_boolean do_header = FALSE;
 244 static bfd_boolean do_dump = FALSE;
 245 static bfd_boolean do_version = FALSE;
 246 static bfd_boolean do_histogram = FALSE;
 247 static bfd_boolean do_debugging = FALSE;
 248 static bfd_boolean do_arch = FALSE;
 249 static bfd_boolean do_notes = FALSE;
 250 static bfd_boolean do_archive_index = FALSE;
 251 static bfd_boolean is_32bit_elf = FALSE;
 252 static bfd_boolean decompress_dumps = FALSE;
 253
 254 struct group_list
 255 {
 256   struct group_list *  next;
 257   unsigned int         section_index;
 258 };
 259
 260 struct group
 261 {
 262   struct group_list *  root;
 263   unsigned int         group_index;
 264 };
 265
 266 static size_t           group_count;
 267 static struct group *   section_groups;
 268 static struct group **  section_headers_groups;
 269
 270 /* A dynamic array of flags indicating for which sections a dump
 271    has been requested via command line switches.  */
 272 static Filedata         cmdline;
 273
 274 static struct dump_list_entry * dump_sects_byname;
 275
 276 /* How to print a vma value.  */
 277 typedef enum print_mode
 278 {
 279   HEX,
 280   DEC,
 281   DEC_5,
 282   UNSIGNED,
 283   PREFIX_HEX,
 284   FULL_HEX,
 285   LONG_HEX
 286 }
 287 print_mode;
 288
 289 /* Versioned symbol info.  */
 290 enum versioned_symbol_info
 291 {
 292   symbol_undefined,
 293   symbol_hidden,
 294   symbol_public
 295 };
 296
 297 static const char * get_symbol_version_string
 298   (Filedata *, bfd_boolean, const char *, unsigned long, unsigned,
 299    Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
 300
 301 #define UNKNOWN -1
 302
 303 #define SECTION_NAME(X)                                         \
 304   ((X) == NULL ? _("<none>")                                    \
 305    : filedata->string_table == NULL ? _("<no-strings>")         \
 306    : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>")    \
 307   : filedata->string_table + (X)->sh_name))
 308
 309 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 310
 311 #define GET_ELF_SYMBOLS(file, section, sym_count)                       \
 312   (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count)      \
 313    : get_64bit_elf_symbols (file, section, sym_count))
 314
 315 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
 316 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 317    already been called and verified that the string exists.  */
 318 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
 319
 320 #define REMOVE_ARCH_BITS(ADDR)                  \
 321   do                                            \
 322     {                                           \
 323       if (filedata->file_header.e_machine == EM_ARM)    \
 324         (ADDR) &= ~1;                           \
 325     }                                           \
 326   while (0)
 327 \f
 328 /* Print a BFD_VMA to an internal buffer, for use in error messages.
 329    BFD_FMA_FMT can't be used in translated strings.  */
 330
 331 static const char *
 332 bfd_vmatoa (char *fmtch, bfd_vma value)
 333 {
 334   /* bfd_vmatoa is used more then once in a printf call for output.
 335      Cycle through an array of buffers.  */
 336   static int buf_pos = 0;
 337   static struct bfd_vmatoa_buf
 338   {
 339     char place[64];
 340   } buf[4];
 341   char *ret;
 342   char fmt[32];
 343
 344   ret = buf[buf_pos++].place;
 345   buf_pos %= ARRAY_SIZE (buf);
 346
 347   sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch);
 348   snprintf (ret, sizeof (buf[0].place), fmt, value);
 349   return ret;
 350 }
 351
 352 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
 353    OFFSET + the offset of the current archive member, if we are examining an
 354    archive.  Put the retrieved data into VAR, if it is not NULL.  Otherwise
 355    allocate a buffer using malloc and fill that.  In either case return the
 356    pointer to the start of the retrieved data or NULL if something went wrong.
 357    If something does go wrong and REASON is not NULL then emit an error
 358    message using REASON as part of the context.  */
 359
 360 static void *
 361 get_data (void *         var,
 362           Filedata *     filedata,
 363           unsigned long  offset,
 364           bfd_size_type  size,
 365           bfd_size_type  nmemb,
 366           const char *   reason)
 367 {
 368   void * mvar;
 369   bfd_size_type amt = size * nmemb;
 370
 371   if (size == 0 || nmemb == 0)
 372     return NULL;
 373
 374   /* If the size_t type is smaller than the bfd_size_type, eg because
 375      you are building a 32-bit tool on a 64-bit host, then make sure
 376      that when the sizes are cast to (size_t) no information is lost.  */
 377   if (sizeof (size_t) < sizeof (bfd_size_type)
 378       && (   (bfd_size_type) ((size_t) size) != size
 379           || (bfd_size_type) ((size_t) nmemb) != nmemb))
 380     {
 381       if (reason)
 382         error (_("Size truncation prevents reading %s"
 383                  " elements of size %s for %s\n"),
 384                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 385       return NULL;
 386     }
 387
 388   /* Check for size overflow.  */
 389   if (amt < nmemb)
 390     {
 391       if (reason)
 392         error (_("Size overflow prevents reading %s"
 393                  " elements of size %s for %s\n"),
 394                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 395       return NULL;
 396     }
 397
 398   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
 399      attempting to allocate memory when the read is bound to fail.  */
 400   if (amt > filedata->file_size
 401       || offset + archive_file_offset + amt > filedata->file_size)
 402     {
 403       if (reason)
 404         error (_("Reading %s bytes extends past end of file for %s\n"),
 405                bfd_vmatoa ("u", amt), reason);
 406       return NULL;
 407     }
 408
 409   if (fseek (filedata->handle, archive_file_offset + offset, SEEK_SET))
 410     {
 411       if (reason)
 412         error (_("Unable to seek to 0x%lx for %s\n"),
 413                archive_file_offset + offset, reason);
 414       return NULL;
 415     }
 416
 417   mvar = var;
 418   if (mvar == NULL)
 419     {
 420       /* Check for overflow.  */
 421       if (nmemb < (~(bfd_size_type) 0 - 1) / size)
 422         /* + 1 so that we can '\0' terminate invalid string table sections.  */
 423         mvar = malloc ((size_t) amt + 1);
 424
 425       if (mvar == NULL)
 426         {
 427           if (reason)
 428             error (_("Out of memory allocating %s bytes for %s\n"),
 429                    bfd_vmatoa ("u", amt), reason);
 430           return NULL;
 431         }
 432
 433       ((char *) mvar)[amt] = '\0';
 434     }
 435
 436   if (fread (mvar, (size_t) size, (size_t) nmemb, filedata->handle) != nmemb)
 437     {
 438       if (reason)
 439         error (_("Unable to read in %s bytes of %s\n"),
 440                bfd_vmatoa ("u", amt), reason);
 441       if (mvar != var)
 442         free (mvar);
 443       return NULL;
 444     }
 445
 446   return mvar;
 447 }
 448
 449 /* Print a VMA value in the MODE specified.
 450    Returns the number of characters displayed.  */
 451
 452 static unsigned int
 453 print_vma (bfd_vma vma, print_mode mode)
 454 {
 455   unsigned int nc = 0;
 456
 457   switch (mode)
 458     {
 459     case FULL_HEX:
 460       nc = printf ("0x");
 461       /* Fall through.  */
 462     case LONG_HEX:
 463 #ifdef BFD64
 464       if (is_32bit_elf)
 465         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
 466 #endif
 467       printf_vma (vma);
 468       return nc + 16;
 469
 470     case DEC_5:
 471       if (vma <= 99999)
 472         return printf ("%5" BFD_VMA_FMT "d", vma);
 473       /* Fall through.  */
 474     case PREFIX_HEX:
 475       nc = printf ("0x");
 476       /* Fall through.  */
 477     case HEX:
 478       return nc + printf ("%" BFD_VMA_FMT "x", vma);
 479
 480     case DEC:
 481       return printf ("%" BFD_VMA_FMT "d", vma);
 482
 483     case UNSIGNED:
 484       return printf ("%" BFD_VMA_FMT "u", vma);
 485
 486     default:
 487       /* FIXME: Report unrecognised mode ?  */
 488       return 0;
 489     }
 490 }
 491
 492 /* Display a symbol on stdout.  Handles the display of control characters and
 493    multibye characters (assuming the host environment supports them).
 494
 495    Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
 496
 497    If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
 498    padding as necessary.
 499
 500    Returns the number of emitted characters.  */
 501
 502 static unsigned int
 503 print_symbol (signed int width, const char *symbol)
 504 {
 505   bfd_boolean extra_padding = FALSE;
 506   signed int num_printed = 0;
 507 #ifdef HAVE_MBSTATE_T
 508   mbstate_t state;
 509 #endif
 510   unsigned int width_remaining;
 511
 512   if (width < 0)
 513     {
 514       /* Keep the width positive.  This helps the code below.  */
 515       width = - width;
 516       extra_padding = TRUE;
 517     }
 518   assert (width != 0);
 519
 520   if (do_wide)
 521     /* Set the remaining width to a very large value.
 522        This simplifies the code below.  */
 523     width_remaining = INT_MAX;
 524   else
 525     width_remaining = width;
 526
 527 #ifdef HAVE_MBSTATE_T
 528   /* Initialise the multibyte conversion state.  */
 529   memset (& state, 0, sizeof (state));
 530 #endif
 531
 532   while (width_remaining)
 533     {
 534       size_t  n;
 535       const char c = *symbol++;
 536
 537       if (c == 0)
 538         break;
 539
 540       /* Do not print control characters directly as they can affect terminal
 541          settings.  Such characters usually appear in the names generated
 542          by the assembler for local labels.  */
 543       if (ISCNTRL (c))
 544         {
 545           if (width_remaining < 2)
 546             break;
 547
 548           printf ("^%c", c + 0x40);
 549           width_remaining -= 2;
 550           num_printed += 2;
 551         }
 552       else if (ISPRINT (c))
 553         {
 554           putchar (c);
 555           width_remaining --;
 556           num_printed ++;
 557         }
 558       else
 559         {
 560 #ifdef HAVE_MBSTATE_T
 561           wchar_t w;
 562 #endif
 563           /* Let printf do the hard work of displaying multibyte characters.  */
 564           printf ("%.1s", symbol - 1);
 565           width_remaining --;
 566           num_printed ++;
 567
 568 #ifdef HAVE_MBSTATE_T
 569           /* Try to find out how many bytes made up the character that was
 570              just printed.  Advance the symbol pointer past the bytes that
 571              were displayed.  */
 572           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 573 #else
 574           n = 1;
 575 #endif
 576           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 577             symbol += (n - 1);
 578         }
 579     }
 580
 581   if (extra_padding && num_printed < width)
 582     {
 583       /* Fill in the remaining spaces.  */
 584       printf ("%-*s", width - num_printed, " ");
 585       num_printed = width;
 586     }
 587
 588   return num_printed;
 589 }
 590
 591 /* Returns a pointer to a static buffer containing a printable version of
 592    the given section's name.  Like print_symbol, except that it does not try
 593    to print multibyte characters, it just interprets them as hex values.  */
 594
 595 static const char *
 596 printable_section_name (Filedata * filedata, const Elf_Internal_Shdr * sec)
 597 {
 598 #define MAX_PRINT_SEC_NAME_LEN 128
 599   static char  sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
 600   const char * name = SECTION_NAME (sec);
 601   char *       buf = sec_name_buf;
 602   char         c;
 603   unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
 604
 605   while ((c = * name ++) != 0)
 606     {
 607       if (ISCNTRL (c))
 608         {
 609           if (remaining < 2)
 610             break;
 611
 612           * buf ++ = '^';
 613           * buf ++ = c + 0x40;
 614           remaining -= 2;
 615         }
 616       else if (ISPRINT (c))
 617         {
 618           * buf ++ = c;
 619           remaining -= 1;
 620         }
 621       else
 622         {
 623           static char hex[17] = "0123456789ABCDEF";
 624
 625           if (remaining < 4)
 626             break;
 627           * buf ++ = '<';
 628           * buf ++ = hex[(c & 0xf0) >> 4];
 629           * buf ++ = hex[c & 0x0f];
 630           * buf ++ = '>';
 631           remaining -= 4;
 632         }
 633
 634       if (remaining == 0)
 635         break;
 636     }
 637
 638   * buf = 0;
 639   return sec_name_buf;
 640 }
 641
 642 static const char *
 643 printable_section_name_from_index (Filedata * filedata, unsigned long ndx)
 644 {
 645   if (ndx >= filedata->file_header.e_shnum)
 646     return _("<corrupt>");
 647
 648   return printable_section_name (filedata, filedata->section_headers + ndx);
 649 }
 650
 651 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 652
 653 static Elf_Internal_Shdr *
 654 find_section (Filedata * filedata, const char * name)
 655 {
 656   unsigned int i;
 657
 658   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       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                   && (filedata->file_header.e_type == ET_EXEC
6272                       || filedata->file_header.e_type == ET_DYN
6273                       /* These next two tests may be redundant, but
6274                          they have been left in for paranoia's sake.  */
6275                       || streq (SECTION_NAME (section), ".rel.dyn")
6276                       || streq (SECTION_NAME (section), ".rela.dyn")))
6277                 /* Dynamic relocations apply to segments, not sections, so
6278                    they do not need an sh_info value.  */
6279                 ;
6280               else
6281                 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6282                       i, section->sh_info);
6283             }
6284           break;
6285
6286         case SHT_DYNAMIC:
6287         case SHT_HASH:
6288         case SHT_SYMTAB_SHNDX:
6289         case SHT_INIT_ARRAY:
6290         case SHT_FINI_ARRAY:
6291         case SHT_PREINIT_ARRAY:
6292           if (section->sh_info != 0)
6293             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6294                   i, section->sh_info);
6295           break;
6296
6297         case SHT_GROUP:
6298         case SHT_SYMTAB:
6299         case SHT_DYNSYM:
6300           /* A symbol index - we assume that it is valid.  */
6301           break;
6302
6303         default:
6304           /* FIXME: Add support for target specific section types.  */
6305           if (section->sh_type == SHT_NOBITS)
6306             /* NOBITS section headers with non-zero sh_info fields can be
6307                created when a binary is stripped of everything but its debug
6308                information.  The stripped sections have their headers
6309                preserved but their types set to SHT_NOBITS.  So do not check
6310                this type of section.  */
6311             ;
6312           else if (section->sh_flags & SHF_INFO_LINK)
6313             {
6314               if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6315                 warn (_("[%2u]: Expected link to another section in info field"), i);
6316             }
6317           else if (section->sh_type < SHT_LOOS
6318                    && (section->sh_flags & SHF_GNU_MBIND) == 0
6319                    && section->sh_info != 0)
6320             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6321                   i, section->sh_info);
6322           break;
6323         }
6324
6325       /* Check the sh_size field.  */
6326       if (section->sh_size > filedata->file_size
6327           && section->sh_type != SHT_NOBITS
6328           && section->sh_type != SHT_NULL
6329           && section->sh_type < SHT_LOOS)
6330         warn (_("Size of section %u is larger than the entire file!\n"), i);
6331
6332       printf ("  [%2u] ", i);
6333       if (do_section_details)
6334         printf ("%s\n      ", printable_section_name (filedata, section));
6335       else
6336         print_symbol (-17, SECTION_NAME (section));
6337
6338       printf (do_wide ? " %-15s " : " %-15.15s ",
6339               get_section_type_name (filedata, section->sh_type));
6340
6341       if (is_32bit_elf)
6342         {
6343           const char * link_too_big = NULL;
6344
6345           print_vma (section->sh_addr, LONG_HEX);
6346
6347           printf ( " %6.6lx %6.6lx %2.2lx",
6348                    (unsigned long) section->sh_offset,
6349                    (unsigned long) section->sh_size,
6350                    (unsigned long) section->sh_entsize);
6351
6352           if (do_section_details)
6353             fputs ("  ", stdout);
6354           else
6355             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6356
6357           if (section->sh_link >= filedata->file_header.e_shnum)
6358             {
6359               link_too_big = "";
6360               /* The sh_link value is out of range.  Normally this indicates
6361                  an error but it can have special values in Solaris binaries.  */
6362               switch (filedata->file_header.e_machine)
6363                 {
6364                 case EM_386:
6365                 case EM_IAMCU:
6366                 case EM_X86_64:
6367                 case EM_L1OM:
6368                 case EM_K1OM:
6369                 case EM_OLD_SPARCV9:
6370                 case EM_SPARC32PLUS:
6371                 case EM_SPARCV9:
6372                 case EM_SPARC:
6373                   if (section->sh_link == (SHN_BEFORE & 0xffff))
6374                     link_too_big = "BEFORE";
6375                   else if (section->sh_link == (SHN_AFTER & 0xffff))
6376                     link_too_big = "AFTER";
6377                   break;
6378                 default:
6379                   break;
6380                 }
6381             }
6382
6383           if (do_section_details)
6384             {
6385               if (link_too_big != NULL && * link_too_big)
6386                 printf ("<%s> ", link_too_big);
6387               else
6388                 printf ("%2u ", section->sh_link);
6389               printf ("%3u %2lu\n", section->sh_info,
6390                       (unsigned long) section->sh_addralign);
6391             }
6392           else
6393             printf ("%2u %3u %2lu\n",
6394                     section->sh_link,
6395                     section->sh_info,
6396                     (unsigned long) section->sh_addralign);
6397
6398           if (link_too_big && ! * link_too_big)
6399             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6400                   i, section->sh_link);
6401         }
6402       else if (do_wide)
6403         {
6404           print_vma (section->sh_addr, LONG_HEX);
6405
6406           if ((long) section->sh_offset == section->sh_offset)
6407             printf (" %6.6lx", (unsigned long) section->sh_offset);
6408           else
6409             {
6410               putchar (' ');
6411               print_vma (section->sh_offset, LONG_HEX);
6412             }
6413
6414           if ((unsigned long) section->sh_size == section->sh_size)
6415             printf (" %6.6lx", (unsigned long) section->sh_size);
6416           else
6417             {
6418               putchar (' ');
6419               print_vma (section->sh_size, LONG_HEX);
6420             }
6421
6422           if ((unsigned long) section->sh_entsize == section->sh_entsize)
6423             printf (" %2.2lx", (unsigned long) section->sh_entsize);
6424           else
6425             {
6426               putchar (' ');
6427               print_vma (section->sh_entsize, LONG_HEX);
6428             }
6429
6430           if (do_section_details)
6431             fputs ("  ", stdout);
6432           else
6433             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6434
6435           printf ("%2u %3u ", section->sh_link, section->sh_info);
6436
6437           if ((unsigned long) section->sh_addralign == section->sh_addralign)
6438             printf ("%2lu\n", (unsigned long) section->sh_addralign);
6439           else
6440             {
6441               print_vma (section->sh_addralign, DEC);
6442               putchar ('\n');
6443             }
6444         }
6445       else if (do_section_details)
6446         {
6447           printf ("       %-15.15s  ",
6448                   get_section_type_name (filedata, section->sh_type));
6449           print_vma (section->sh_addr, LONG_HEX);
6450           if ((long) section->sh_offset == section->sh_offset)
6451             printf ("  %16.16lx", (unsigned long) section->sh_offset);
6452           else
6453             {
6454               printf ("  ");
6455               print_vma (section->sh_offset, LONG_HEX);
6456             }
6457           printf ("  %u\n       ", section->sh_link);
6458           print_vma (section->sh_size, LONG_HEX);
6459           putchar (' ');
6460           print_vma (section->sh_entsize, LONG_HEX);
6461
6462           printf ("  %-16u  %lu\n",
6463                   section->sh_info,
6464                   (unsigned long) section->sh_addralign);
6465         }
6466       else
6467         {
6468           putchar (' ');
6469           print_vma (section->sh_addr, LONG_HEX);
6470           if ((long) section->sh_offset == section->sh_offset)
6471             printf ("  %8.8lx", (unsigned long) section->sh_offset);
6472           else
6473             {
6474               printf ("  ");
6475               print_vma (section->sh_offset, LONG_HEX);
6476             }
6477           printf ("\n       ");
6478           print_vma (section->sh_size, LONG_HEX);
6479           printf ("  ");
6480           print_vma (section->sh_entsize, LONG_HEX);
6481
6482           printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6483
6484           printf ("     %2u   %3u     %lu\n",
6485                   section->sh_link,
6486                   section->sh_info,
6487                   (unsigned long) section->sh_addralign);
6488         }
6489
6490       if (do_section_details)
6491         {
6492           printf ("       %s\n", get_elf_section_flags (filedata, section->sh_flags));
6493           if ((section->sh_flags & SHF_COMPRESSED) != 0)
6494             {
6495               /* Minimum section size is 12 bytes for 32-bit compression
6496                  header + 12 bytes for compressed data header.  */
6497               unsigned char buf[24];
6498
6499               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6500               if (get_data (&buf, filedata, section->sh_offset, 1,
6501                             sizeof (buf), _("compression header")))
6502                 {
6503                   Elf_Internal_Chdr chdr;
6504
6505                   (void) get_compression_header (&chdr, buf, sizeof (buf));
6506
6507                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6508                     printf ("       ZLIB, ");
6509                   else
6510                     printf (_("       [<unknown>: 0x%x], "),
6511                             chdr.ch_type);
6512                   print_vma (chdr.ch_size, LONG_HEX);
6513                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6514                 }
6515             }
6516         }
6517     }
6518
6519   if (!do_section_details)
6520     {
6521       /* The ordering of the letters shown here matches the ordering of the
6522          corresponding SHF_xxx values, and hence the order in which these
6523          letters will be displayed to the user.  */
6524       printf (_("Key to Flags:\n\
6525   W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6526   L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6527   C (compressed), x (unknown), o (OS specific), E (exclude),\n  "));
6528       if (filedata->file_header.e_machine == EM_X86_64
6529           || filedata->file_header.e_machine == EM_L1OM
6530           || filedata->file_header.e_machine == EM_K1OM)
6531         printf (_("l (large), "));
6532       else if (filedata->file_header.e_machine == EM_ARM)
6533         printf (_("y (purecode), "));
6534       else if (filedata->file_header.e_machine == EM_PPC)
6535         printf (_("v (VLE), "));
6536       printf ("p (processor specific)\n");
6537     }
6538
6539   return TRUE;
6540 }
6541
6542 static const char *
6543 get_group_flags (unsigned int flags)
6544 {
6545   static char buff[128];
6546
6547   if (flags == 0)
6548     return "";
6549   else if (flags == GRP_COMDAT)
6550     return "COMDAT ";
6551
6552   snprintf (buff, 14, _("[0x%x: "), flags);
6553
6554   flags &= ~ GRP_COMDAT;
6555   if (flags & GRP_MASKOS)
6556     {
6557       strcat (buff, "<OS specific>");
6558       flags &= ~ GRP_MASKOS;
6559     }
6560
6561   if (flags & GRP_MASKPROC)
6562     {
6563       strcat (buff, "<PROC specific>");
6564       flags &= ~ GRP_MASKPROC;
6565     }
6566
6567   if (flags)
6568     strcat (buff, "<unknown>");
6569
6570   strcat (buff, "]");
6571   return buff;
6572 }
6573
6574 static bfd_boolean
6575 process_section_groups (Filedata * filedata)
6576 {
6577   Elf_Internal_Shdr * section;
6578   unsigned int i;
6579   struct group * group;
6580   Elf_Internal_Shdr * symtab_sec;
6581   Elf_Internal_Shdr * strtab_sec;
6582   Elf_Internal_Sym * symtab;
6583   unsigned long num_syms;
6584   char * strtab;
6585   size_t strtab_size;
6586
6587   /* Don't process section groups unless needed.  */
6588   if (!do_unwind && !do_section_groups)
6589     return TRUE;
6590
6591   if (filedata->file_header.e_shnum == 0)
6592     {
6593       if (do_section_groups)
6594         printf (_("\nThere are no sections to group in this file.\n"));
6595
6596       return TRUE;
6597     }
6598
6599   if (filedata->section_headers == NULL)
6600     {
6601       error (_("Section headers are not available!\n"));
6602       /* PR 13622: This can happen with a corrupt ELF header.  */
6603       return FALSE;
6604     }
6605
6606   section_headers_groups = (struct group **) calloc (filedata->file_header.e_shnum,
6607                                                      sizeof (struct group *));
6608
6609   if (section_headers_groups == NULL)
6610     {
6611       error (_("Out of memory reading %u section group headers\n"),
6612              filedata->file_header.e_shnum);
6613       return FALSE;
6614     }
6615
6616   /* Scan the sections for the group section.  */
6617   group_count = 0;
6618   for (i = 0, section = filedata->section_headers;
6619        i < filedata->file_header.e_shnum;
6620        i++, section++)
6621     if (section->sh_type == SHT_GROUP)
6622       group_count++;
6623
6624   if (group_count == 0)
6625     {
6626       if (do_section_groups)
6627         printf (_("\nThere are no section groups in this file.\n"));
6628
6629       return TRUE;
6630     }
6631
6632   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6633
6634   if (section_groups == NULL)
6635     {
6636       error (_("Out of memory reading %lu groups\n"),
6637              (unsigned long) group_count);
6638       return FALSE;
6639     }
6640
6641   symtab_sec = NULL;
6642   strtab_sec = NULL;
6643   symtab = NULL;
6644   num_syms = 0;
6645   strtab = NULL;
6646   strtab_size = 0;
6647   for (i = 0, section = filedata->section_headers, group = section_groups;
6648        i < filedata->file_header.e_shnum;
6649        i++, section++)
6650     {
6651       if (section->sh_type == SHT_GROUP)
6652         {
6653           const char * name = printable_section_name (filedata, section);
6654           const char * group_name;
6655           unsigned char * start;
6656           unsigned char * indices;
6657           unsigned int entry, j, size;
6658           Elf_Internal_Shdr * sec;
6659           Elf_Internal_Sym * sym;
6660
6661           /* Get the symbol table.  */
6662           if (section->sh_link >= filedata->file_header.e_shnum
6663               || ((sec = filedata->section_headers + section->sh_link)->sh_type
6664                   != SHT_SYMTAB))
6665             {
6666               error (_("Bad sh_link in group section `%s'\n"), name);
6667               continue;
6668             }
6669
6670           if (symtab_sec != sec)
6671             {
6672               symtab_sec = sec;
6673               if (symtab)
6674                 free (symtab);
6675               symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
6676             }
6677
6678           if (symtab == NULL)
6679             {
6680               error (_("Corrupt header in group section `%s'\n"), name);
6681               continue;
6682             }
6683
6684           if (section->sh_info >= num_syms)
6685             {
6686               error (_("Bad sh_info in group section `%s'\n"), name);
6687               continue;
6688             }
6689
6690           sym = symtab + section->sh_info;
6691
6692           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6693             {
6694               if (sym->st_shndx == 0
6695                   || sym->st_shndx >= filedata->file_header.e_shnum)
6696                 {
6697                   error (_("Bad sh_info in group section `%s'\n"), name);
6698                   continue;
6699                 }
6700
6701               group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
6702               strtab_sec = NULL;
6703               if (strtab)
6704                 free (strtab);
6705               strtab = NULL;
6706               strtab_size = 0;
6707             }
6708           else
6709             {
6710               /* Get the string table.  */
6711               if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
6712                 {
6713                   strtab_sec = NULL;
6714                   if (strtab)
6715                     free (strtab);
6716                   strtab = NULL;
6717                   strtab_size = 0;
6718                 }
6719               else if (strtab_sec
6720                        != (sec = filedata->section_headers + symtab_sec->sh_link))
6721                 {
6722                   strtab_sec = sec;
6723                   if (strtab)
6724                     free (strtab);
6725
6726                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
6727                                               1, strtab_sec->sh_size,
6728                                               _("string table"));
6729                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6730                 }
6731               group_name = sym->st_name < strtab_size
6732                 ? strtab + sym->st_name : _("<corrupt>");
6733             }
6734
6735           /* PR 17531: file: loop.  */
6736           if (section->sh_entsize > section->sh_size)
6737             {
6738               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6739                      printable_section_name (filedata, section),
6740                      (unsigned long) section->sh_entsize,
6741                      (unsigned long) section->sh_size);
6742               break;
6743             }
6744
6745           start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
6746                                               1, section->sh_size,
6747                                               _("section data"));
6748           if (start == NULL)
6749             continue;
6750
6751           indices = start;
6752           size = (section->sh_size / section->sh_entsize) - 1;
6753           entry = byte_get (indices, 4);
6754           indices += 4;
6755
6756           if (do_section_groups)
6757             {
6758               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6759                       get_group_flags (entry), i, name, group_name, size);
6760
6761               printf (_("   [Index]    Name\n"));
6762             }
6763
6764           group->group_index = i;
6765
6766           for (j = 0; j < size; j++)
6767             {
6768               struct group_list * g;
6769
6770               entry = byte_get (indices, 4);
6771               indices += 4;
6772
6773               if (entry >= filedata->file_header.e_shnum)
6774                 {
6775                   static unsigned num_group_errors = 0;
6776
6777                   if (num_group_errors ++ < 10)
6778                     {
6779                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6780                              entry, i, filedata->file_header.e_shnum - 1);
6781                       if (num_group_errors == 10)
6782                         warn (_("Further error messages about overlarge group section indicies suppressed\n"));
6783                     }
6784                   continue;
6785                 }
6786
6787               if (section_headers_groups [entry] != NULL)
6788                 {
6789                   if (entry)
6790                     {
6791                       static unsigned num_errs = 0;
6792
6793                       if (num_errs ++ < 10)
6794                         {
6795                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6796                                  entry, i,
6797                                  section_headers_groups [entry]->group_index);
6798                           if (num_errs == 10)
6799                             warn (_("Further error messages about already contained group sections suppressed\n"));
6800                         }
6801                       continue;
6802                     }
6803                   else
6804                     {
6805                       /* Intel C/C++ compiler may put section 0 in a
6806                          section group.  We just warn it the first time
6807                          and ignore it afterwards.  */
6808                       static bfd_boolean warned = FALSE;
6809                       if (!warned)
6810                         {
6811                           error (_("section 0 in group section [%5u]\n"),
6812                                  section_headers_groups [entry]->group_index);
6813                           warned = TRUE;
6814                         }
6815                     }
6816                 }
6817
6818               section_headers_groups [entry] = group;
6819
6820               if (do_section_groups)
6821                 {
6822                   sec = filedata->section_headers + entry;
6823                   printf ("   [%5u]   %s\n", entry, printable_section_name (filedata, sec));
6824                 }
6825
6826               g = (struct group_list *) xmalloc (sizeof (struct group_list));
6827               g->section_index = entry;
6828               g->next = group->root;
6829               group->root = g;
6830             }
6831
6832           if (start)
6833             free (start);
6834
6835           group++;
6836         }
6837     }
6838
6839   if (symtab)
6840     free (symtab);
6841   if (strtab)
6842     free (strtab);
6843   return TRUE;
6844 }
6845
6846 /* Data used to display dynamic fixups.  */
6847
6848 struct ia64_vms_dynfixup
6849 {
6850   bfd_vma needed_ident;         /* Library ident number.  */
6851   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
6852   bfd_vma fixup_needed;         /* Index of the library.  */
6853   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
6854   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
6855 };
6856
6857 /* Data used to display dynamic relocations.  */
6858
6859 struct ia64_vms_dynimgrela
6860 {
6861   bfd_vma img_rela_cnt;         /* Number of relocations.  */
6862   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
6863 };
6864
6865 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6866    library).  */
6867
6868 static bfd_boolean
6869 dump_ia64_vms_dynamic_fixups (Filedata *                  filedata,
6870                               struct ia64_vms_dynfixup *  fixup,
6871                               const char *                strtab,
6872                               unsigned int                strtab_sz)
6873 {
6874   Elf64_External_VMS_IMAGE_FIXUP * imfs;
6875   long i;
6876   const char * lib_name;
6877
6878   imfs = get_data (NULL, filedata, dynamic_addr + fixup->fixup_rela_off,
6879                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
6880                    _("dynamic section image fixups"));
6881   if (!imfs)
6882     return FALSE;
6883
6884   if (fixup->needed < strtab_sz)
6885     lib_name = strtab + fixup->needed;
6886   else
6887     {
6888       warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6889             (unsigned long) fixup->needed);
6890       lib_name = "???";
6891     }
6892   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6893           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6894   printf
6895     (_("Seg Offset           Type                             SymVec DataType\n"));
6896
6897   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6898     {
6899       unsigned int type;
6900       const char *rtype;
6901
6902       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6903       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6904       type = BYTE_GET (imfs [i].type);
6905       rtype = elf_ia64_reloc_type (type);
6906       if (rtype == NULL)
6907         printf (" 0x%08x                       ", type);
6908       else
6909         printf (" %-32s ", rtype);
6910       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6911       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6912     }
6913
6914   free (imfs);
6915   return TRUE;
6916 }
6917
6918 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
6919
6920 static bfd_boolean
6921 dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
6922 {
6923   Elf64_External_VMS_IMAGE_RELA *imrs;
6924   long i;
6925
6926   imrs = get_data (NULL, filedata, dynamic_addr + imgrela->img_rela_off,
6927                    1, imgrela->img_rela_cnt * sizeof (*imrs),
6928                    _("dynamic section image relocations"));
6929   if (!imrs)
6930     return FALSE;
6931
6932   printf (_("\nImage relocs\n"));
6933   printf
6934     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
6935
6936   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6937     {
6938       unsigned int type;
6939       const char *rtype;
6940
6941       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6942       printf ("%08" BFD_VMA_FMT "x ",
6943               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6944       type = BYTE_GET (imrs [i].type);
6945       rtype = elf_ia64_reloc_type (type);
6946       if (rtype == NULL)
6947         printf ("0x%08x                      ", type);
6948       else
6949         printf ("%-31s ", rtype);
6950       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6951       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6952       printf ("%08" BFD_VMA_FMT "x\n",
6953               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6954     }
6955
6956   free (imrs);
6957   return TRUE;
6958 }
6959
6960 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
6961
6962 static bfd_boolean
6963 process_ia64_vms_dynamic_relocs (Filedata * filedata)
6964 {
6965   struct ia64_vms_dynfixup fixup;
6966   struct ia64_vms_dynimgrela imgrela;
6967   Elf_Internal_Dyn *entry;
6968   bfd_vma strtab_off = 0;
6969   bfd_vma strtab_sz = 0;
6970   char *strtab = NULL;
6971   bfd_boolean res = TRUE;
6972
6973   memset (&fixup, 0, sizeof (fixup));
6974   memset (&imgrela, 0, sizeof (imgrela));
6975
6976   /* Note: the order of the entries is specified by the OpenVMS specs.  */
6977   for (entry = dynamic_section;
6978        entry < dynamic_section + dynamic_nent;
6979        entry++)
6980     {
6981       switch (entry->d_tag)
6982         {
6983         case DT_IA_64_VMS_STRTAB_OFFSET:
6984           strtab_off = entry->d_un.d_val;
6985           break;
6986         case DT_STRSZ:
6987           strtab_sz = entry->d_un.d_val;
6988           if (strtab == NULL)
6989             strtab = get_data (NULL, filedata, dynamic_addr + strtab_off,
6990                                1, strtab_sz, _("dynamic string section"));
6991           break;
6992
6993         case DT_IA_64_VMS_NEEDED_IDENT:
6994           fixup.needed_ident = entry->d_un.d_val;
6995           break;
6996         case DT_NEEDED:
6997           fixup.needed = entry->d_un.d_val;
6998           break;
6999         case DT_IA_64_VMS_FIXUP_NEEDED:
7000           fixup.fixup_needed = entry->d_un.d_val;
7001           break;
7002         case DT_IA_64_VMS_FIXUP_RELA_CNT:
7003           fixup.fixup_rela_cnt = entry->d_un.d_val;
7004           break;
7005         case DT_IA_64_VMS_FIXUP_RELA_OFF:
7006           fixup.fixup_rela_off = entry->d_un.d_val;
7007           if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7008             res = FALSE;
7009           break;
7010         case DT_IA_64_VMS_IMG_RELA_CNT:
7011           imgrela.img_rela_cnt = entry->d_un.d_val;
7012           break;
7013         case DT_IA_64_VMS_IMG_RELA_OFF:
7014           imgrela.img_rela_off = entry->d_un.d_val;
7015           if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7016             res = FALSE;
7017           break;
7018
7019         default:
7020           break;
7021         }
7022     }
7023
7024   if (strtab != NULL)
7025     free (strtab);
7026
7027   return res;
7028 }
7029
7030 static struct
7031 {
7032   const char * name;
7033   int reloc;
7034   int size;
7035   int rela;
7036 }
7037   dynamic_relocations [] =
7038 {
7039   { "REL", DT_REL, DT_RELSZ, FALSE },
7040   { "RELA", DT_RELA, DT_RELASZ, TRUE },
7041   { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7042 };
7043
7044 /* Process the reloc section.  */
7045
7046 static bfd_boolean
7047 process_relocs (Filedata * filedata)
7048 {
7049   unsigned long rel_size;
7050   unsigned long rel_offset;
7051
7052   if (!do_reloc)
7053     return TRUE;
7054
7055   if (do_using_dynamic)
7056     {
7057       int          is_rela;
7058       const char * name;
7059       bfd_boolean  has_dynamic_reloc;
7060       unsigned int i;
7061
7062       has_dynamic_reloc = FALSE;
7063
7064       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7065         {
7066           is_rela = dynamic_relocations [i].rela;
7067           name = dynamic_relocations [i].name;
7068           rel_size = dynamic_info [dynamic_relocations [i].size];
7069           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7070
7071           if (rel_size)
7072             has_dynamic_reloc = TRUE;
7073
7074           if (is_rela == UNKNOWN)
7075             {
7076               if (dynamic_relocations [i].reloc == DT_JMPREL)
7077                 switch (dynamic_info[DT_PLTREL])
7078                   {
7079                   case DT_REL:
7080                     is_rela = FALSE;
7081                     break;
7082                   case DT_RELA:
7083                     is_rela = TRUE;
7084                     break;
7085                   }
7086             }
7087
7088           if (rel_size)
7089             {
7090               printf
7091                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7092                  name, rel_offset, rel_size);
7093
7094               dump_relocations (filedata,
7095                                 offset_from_vma (filedata, rel_offset, rel_size),
7096                                 rel_size,
7097                                 dynamic_symbols, num_dynamic_syms,
7098                                 dynamic_strings, dynamic_strings_length,
7099                                 is_rela, TRUE /* is_dynamic */);
7100             }
7101         }
7102
7103       if (is_ia64_vms (filedata))
7104         if (process_ia64_vms_dynamic_relocs (filedata))
7105           has_dynamic_reloc = TRUE;
7106
7107       if (! has_dynamic_reloc)
7108         printf (_("\nThere are no dynamic relocations in this file.\n"));
7109     }
7110   else
7111     {
7112       Elf_Internal_Shdr * section;
7113       unsigned long i;
7114       bfd_boolean found = FALSE;
7115
7116       for (i = 0, section = filedata->section_headers;
7117            i < filedata->file_header.e_shnum;
7118            i++, section++)
7119         {
7120           if (   section->sh_type != SHT_RELA
7121               && section->sh_type != SHT_REL)
7122             continue;
7123
7124           rel_offset = section->sh_offset;
7125           rel_size   = section->sh_size;
7126
7127           if (rel_size)
7128             {
7129               Elf_Internal_Shdr * strsec;
7130               int is_rela;
7131               unsigned long num_rela;
7132
7133               printf (_("\nRelocation section "));
7134
7135               if (filedata->string_table == NULL)
7136                 printf ("%d", section->sh_name);
7137               else
7138                 printf ("'%s'", printable_section_name (filedata, section));
7139
7140               num_rela = rel_size / section->sh_entsize;
7141               printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7142                                 " at offset 0x%lx contains %lu entries:\n",
7143                                 num_rela),
7144                       rel_offset, num_rela);
7145
7146               is_rela = section->sh_type == SHT_RELA;
7147
7148               if (section->sh_link != 0
7149                   && section->sh_link < filedata->file_header.e_shnum)
7150                 {
7151                   Elf_Internal_Shdr * symsec;
7152                   Elf_Internal_Sym *  symtab;
7153                   unsigned long nsyms;
7154                   unsigned long strtablen = 0;
7155                   char * strtab = NULL;
7156
7157                   symsec = filedata->section_headers + section->sh_link;
7158                   if (symsec->sh_type != SHT_SYMTAB
7159                       && symsec->sh_type != SHT_DYNSYM)
7160                     continue;
7161
7162                   symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
7163
7164                   if (symtab == NULL)
7165                     continue;
7166
7167                   if (symsec->sh_link != 0
7168                       && symsec->sh_link < filedata->file_header.e_shnum)
7169                     {
7170                       strsec = filedata->section_headers + symsec->sh_link;
7171
7172                       strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7173                                                   1, strsec->sh_size,
7174                                                   _("string table"));
7175                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
7176                     }
7177
7178                   dump_relocations (filedata, rel_offset, rel_size,
7179                                     symtab, nsyms, strtab, strtablen,
7180                                     is_rela,
7181                                     symsec->sh_type == SHT_DYNSYM);
7182                   if (strtab)
7183                     free (strtab);
7184                   free (symtab);
7185                 }
7186               else
7187                 dump_relocations (filedata, rel_offset, rel_size,
7188                                   NULL, 0, NULL, 0, is_rela,
7189                                   FALSE /* is_dynamic */);
7190
7191               found = TRUE;
7192             }
7193         }
7194
7195       if (! found)
7196         {
7197           /* Users sometimes forget the -D option, so try to be helpful.  */
7198           for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7199             {
7200               if (dynamic_info [dynamic_relocations [i].size])
7201                 {
7202                   printf (_("\nThere are no static relocations in this file."));
7203                   printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7204
7205                   break;
7206                 }
7207             }
7208           if (i == ARRAY_SIZE (dynamic_relocations))
7209             printf (_("\nThere are no relocations in this file.\n"));
7210         }
7211     }
7212
7213   return TRUE;
7214 }
7215
7216 /* An absolute address consists of a section and an offset.  If the
7217    section is NULL, the offset itself is the address, otherwise, the
7218    address equals to LOAD_ADDRESS(section) + offset.  */
7219
7220 struct absaddr
7221 {
7222   unsigned short section;
7223   bfd_vma offset;
7224 };
7225
7226 #define ABSADDR(a) \
7227   ((a).section \
7228    ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7229    : (a).offset)
7230
7231 /* Find the nearest symbol at or below ADDR.  Returns the symbol
7232    name, if found, and the offset from the symbol to ADDR.  */
7233
7234 static void
7235 find_symbol_for_address (Filedata *          filedata,
7236                          Elf_Internal_Sym *  symtab,
7237                          unsigned long       nsyms,
7238                          const char *        strtab,
7239                          unsigned long       strtab_size,
7240                          struct absaddr      addr,
7241                          const char **       symname,
7242                          bfd_vma *           offset)
7243 {
7244   bfd_vma dist = 0x100000;
7245   Elf_Internal_Sym * sym;
7246   Elf_Internal_Sym * beg;
7247   Elf_Internal_Sym * end;
7248   Elf_Internal_Sym * best = NULL;
7249
7250   REMOVE_ARCH_BITS (addr.offset);
7251   beg = symtab;
7252   end = symtab + nsyms;
7253
7254   while (beg < end)
7255     {
7256       bfd_vma value;
7257
7258       sym = beg + (end - beg) / 2;
7259
7260       value = sym->st_value;
7261       REMOVE_ARCH_BITS (value);
7262
7263       if (sym->st_name != 0
7264           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7265           && addr.offset >= value
7266           && addr.offset - value < dist)
7267         {
7268           best = sym;
7269           dist = addr.offset - value;
7270           if (!dist)
7271             break;
7272         }
7273
7274       if (addr.offset < value)
7275         end = sym;
7276       else
7277         beg = sym + 1;
7278     }
7279
7280   if (best)
7281     {
7282       *symname = (best->st_name >= strtab_size
7283                   ? _("<corrupt>") : strtab + best->st_name);
7284       *offset = dist;
7285       return;
7286     }
7287
7288   *symname = NULL;
7289   *offset = addr.offset;
7290 }
7291
7292 static /* signed */ int
7293 symcmp (const void *p, const void *q)
7294 {
7295   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7296   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7297
7298   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7299 }
7300
7301 /* Process the unwind section.  */
7302
7303 #include "unwind-ia64.h"
7304
7305 struct ia64_unw_table_entry
7306 {
7307   struct absaddr start;
7308   struct absaddr end;
7309   struct absaddr info;
7310 };
7311
7312 struct ia64_unw_aux_info
7313 {
7314   struct ia64_unw_table_entry * table;          /* Unwind table.  */
7315   unsigned long                 table_len;      /* Length of unwind table.  */
7316   unsigned char *               info;           /* Unwind info.  */
7317   unsigned long                 info_size;      /* Size of unwind info.  */
7318   bfd_vma                       info_addr;      /* Starting address of unwind info.  */
7319   bfd_vma                       seg_base;       /* Starting address of segment.  */
7320   Elf_Internal_Sym *            symtab;         /* The symbol table.  */
7321   unsigned long                 nsyms;          /* Number of symbols.  */
7322   Elf_Internal_Sym *            funtab;         /* Sorted table of STT_FUNC symbols.  */
7323   unsigned long                 nfuns;          /* Number of entries in funtab.  */
7324   char *                        strtab;         /* The string table.  */
7325   unsigned long                 strtab_size;    /* Size of string table.  */
7326 };
7327
7328 static bfd_boolean
7329 dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7330 {
7331   struct ia64_unw_table_entry * tp;
7332   unsigned long j, nfuns;
7333   int in_body;
7334   bfd_boolean res = TRUE;
7335
7336   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7337   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7338     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7339       aux->funtab[nfuns++] = aux->symtab[j];
7340   aux->nfuns = nfuns;
7341   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7342
7343   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7344     {
7345       bfd_vma stamp;
7346       bfd_vma offset;
7347       const unsigned char * dp;
7348       const unsigned char * head;
7349       const unsigned char * end;
7350       const char * procname;
7351
7352       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7353                                aux->strtab_size, tp->start, &procname, &offset);
7354
7355       fputs ("\n<", stdout);
7356
7357       if (procname)
7358         {
7359           fputs (procname, stdout);
7360
7361           if (offset)
7362             printf ("+%lx", (unsigned long) offset);
7363         }
7364
7365       fputs (">: [", stdout);
7366       print_vma (tp->start.offset, PREFIX_HEX);
7367       fputc ('-', stdout);
7368       print_vma (tp->end.offset, PREFIX_HEX);
7369       printf ("], info at +0x%lx\n",
7370               (unsigned long) (tp->info.offset - aux->seg_base));
7371
7372       /* PR 17531: file: 86232b32.  */
7373       if (aux->info == NULL)
7374         continue;
7375
7376       /* PR 17531: file: 0997b4d1.  */
7377       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7378         {
7379           warn (_("Invalid offset %lx in table entry %ld\n"),
7380                 (long) tp->info.offset, (long) (tp - aux->table));
7381           res = FALSE;
7382           continue;
7383         }
7384
7385       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7386       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7387
7388       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7389               (unsigned) UNW_VER (stamp),
7390               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7391               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7392               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7393               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7394
7395       if (UNW_VER (stamp) != 1)
7396         {
7397           printf (_("\tUnknown version.\n"));
7398           continue;
7399         }
7400
7401       in_body = 0;
7402       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7403       /* PR 17531: file: 16ceda89.  */
7404       if (end > aux->info + aux->info_size)
7405         end = aux->info + aux->info_size;
7406       for (dp = head + 8; dp < end;)
7407         dp = unw_decode (dp, in_body, & in_body, end);
7408     }
7409
7410   free (aux->funtab);
7411
7412   return res;
7413 }
7414
7415 static bfd_boolean
7416 slurp_ia64_unwind_table (Filedata *                  filedata,
7417                          struct ia64_unw_aux_info *  aux,
7418                          Elf_Internal_Shdr *         sec)
7419 {
7420   unsigned long size, nrelas, i;
7421   Elf_Internal_Phdr * seg;
7422   struct ia64_unw_table_entry * tep;
7423   Elf_Internal_Shdr * relsec;
7424   Elf_Internal_Rela * rela;
7425   Elf_Internal_Rela * rp;
7426   unsigned char * table;
7427   unsigned char * tp;
7428   Elf_Internal_Sym * sym;
7429   const char * relname;
7430
7431   aux->table_len = 0;
7432
7433   /* First, find the starting address of the segment that includes
7434      this section: */
7435
7436   if (filedata->file_header.e_phnum)
7437     {
7438       if (! get_program_headers (filedata))
7439           return FALSE;
7440
7441       for (seg = filedata->program_headers;
7442            seg < filedata->program_headers + filedata->file_header.e_phnum;
7443            ++seg)
7444         {
7445           if (seg->p_type != PT_LOAD)
7446             continue;
7447
7448           if (sec->sh_addr >= seg->p_vaddr
7449               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7450             {
7451               aux->seg_base = seg->p_vaddr;
7452               break;
7453             }
7454         }
7455     }
7456
7457   /* Second, build the unwind table from the contents of the unwind section:  */
7458   size = sec->sh_size;
7459   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7460                                       _("unwind table"));
7461   if (!table)
7462     return FALSE;
7463
7464   aux->table_len = size / (3 * eh_addr_size);
7465   aux->table = (struct ia64_unw_table_entry *)
7466     xcmalloc (aux->table_len, sizeof (aux->table[0]));
7467   tep = aux->table;
7468
7469   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7470     {
7471       tep->start.section = SHN_UNDEF;
7472       tep->end.section   = SHN_UNDEF;
7473       tep->info.section  = SHN_UNDEF;
7474       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7475       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7476       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7477       tep->start.offset += aux->seg_base;
7478       tep->end.offset   += aux->seg_base;
7479       tep->info.offset  += aux->seg_base;
7480     }
7481   free (table);
7482
7483   /* Third, apply any relocations to the unwind table:  */
7484   for (relsec = filedata->section_headers;
7485        relsec < filedata->section_headers + filedata->file_header.e_shnum;
7486        ++relsec)
7487     {
7488       if (relsec->sh_type != SHT_RELA
7489           || relsec->sh_info >= filedata->file_header.e_shnum
7490           || filedata->section_headers + relsec->sh_info != sec)
7491         continue;
7492
7493       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7494                               & rela, & nrelas))
7495         {
7496           free (aux->table);
7497           aux->table = NULL;
7498           aux->table_len = 0;
7499           return FALSE;
7500         }
7501
7502       for (rp = rela; rp < rela + nrelas; ++rp)
7503         {
7504           relname = elf_ia64_reloc_type (get_reloc_type (filedata, rp->r_info));
7505           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7506
7507           /* PR 17531: file: 9fa67536.  */
7508           if (relname == NULL)
7509             {
7510               warn (_("Skipping unknown relocation type: %u\n"),
7511                     get_reloc_type (filedata, rp->r_info));
7512               continue;
7513             }
7514
7515           if (! const_strneq (relname, "R_IA64_SEGREL"))
7516             {
7517               warn (_("Skipping unexpected relocation type: %s\n"), relname);
7518               continue;
7519             }
7520
7521           i = rp->r_offset / (3 * eh_addr_size);
7522
7523           /* PR 17531: file: 5bc8d9bf.  */
7524           if (i >= aux->table_len)
7525             {
7526               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7527               continue;
7528             }
7529
7530           switch (rp->r_offset / eh_addr_size % 3)
7531             {
7532             case 0:
7533               aux->table[i].start.section = sym->st_shndx;
7534               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
7535               break;
7536             case 1:
7537               aux->table[i].end.section   = sym->st_shndx;
7538               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
7539               break;
7540             case 2:
7541               aux->table[i].info.section  = sym->st_shndx;
7542               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
7543               break;
7544             default:
7545               break;
7546             }
7547         }
7548
7549       free (rela);
7550     }
7551
7552   return TRUE;
7553 }
7554
7555 static bfd_boolean
7556 ia64_process_unwind (Filedata * filedata)
7557 {
7558   Elf_Internal_Shdr * sec;
7559   Elf_Internal_Shdr * unwsec = NULL;
7560   Elf_Internal_Shdr * strsec;
7561   unsigned long i, unwcount = 0, unwstart = 0;
7562   struct ia64_unw_aux_info aux;
7563   bfd_boolean res = TRUE;
7564
7565   memset (& aux, 0, sizeof (aux));
7566
7567   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7568     {
7569       if (sec->sh_type == SHT_SYMTAB
7570           && sec->sh_link < filedata->file_header.e_shnum)
7571         {
7572           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
7573
7574           strsec = filedata->section_headers + sec->sh_link;
7575           if (aux.strtab != NULL)
7576             {
7577               error (_("Multiple auxillary string tables encountered\n"));
7578               free (aux.strtab);
7579               res = FALSE;
7580             }
7581           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7582                                           1, strsec->sh_size,
7583                                           _("string table"));
7584           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7585         }
7586       else if (sec->sh_type == SHT_IA_64_UNWIND)
7587         unwcount++;
7588     }
7589
7590   if (!unwcount)
7591     printf (_("\nThere are no unwind sections in this file.\n"));
7592
7593   while (unwcount-- > 0)
7594     {
7595       char * suffix;
7596       size_t len, len2;
7597
7598       for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7599            i < filedata->file_header.e_shnum; ++i, ++sec)
7600         if (sec->sh_type == SHT_IA_64_UNWIND)
7601           {
7602             unwsec = sec;
7603             break;
7604           }
7605       /* We have already counted the number of SHT_IA64_UNWIND
7606          sections so the loop above should never fail.  */
7607       assert (unwsec != NULL);
7608
7609       unwstart = i + 1;
7610       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7611
7612       if ((unwsec->sh_flags & SHF_GROUP) != 0)
7613         {
7614           /* We need to find which section group it is in.  */
7615           struct group_list * g;
7616
7617           if (section_headers_groups == NULL
7618               || section_headers_groups [i] == NULL)
7619             i = filedata->file_header.e_shnum;
7620           else
7621             {
7622               g = section_headers_groups [i]->root;
7623
7624               for (; g != NULL; g = g->next)
7625                 {
7626                   sec = filedata->section_headers + g->section_index;
7627
7628                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7629                     break;
7630                 }
7631
7632               if (g == NULL)
7633                 i = filedata->file_header.e_shnum;
7634             }
7635         }
7636       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7637         {
7638           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
7639           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7640           suffix = SECTION_NAME (unwsec) + len;
7641           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7642                ++i, ++sec)
7643             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7644                 && streq (SECTION_NAME (sec) + len2, suffix))
7645               break;
7646         }
7647       else
7648         {
7649           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7650              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
7651           len = sizeof (ELF_STRING_ia64_unwind) - 1;
7652           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7653           suffix = "";
7654           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7655             suffix = SECTION_NAME (unwsec) + len;
7656           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7657                ++i, ++sec)
7658             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7659                 && streq (SECTION_NAME (sec) + len2, suffix))
7660               break;
7661         }
7662
7663       if (i == filedata->file_header.e_shnum)
7664         {
7665           printf (_("\nCould not find unwind info section for "));
7666
7667           if (filedata->string_table == NULL)
7668             printf ("%d", unwsec->sh_name);
7669           else
7670             printf ("'%s'", printable_section_name (filedata, unwsec));
7671         }
7672       else
7673         {
7674           aux.info_addr = sec->sh_addr;
7675           aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
7676                                                  sec->sh_size,
7677                                                  _("unwind info"));
7678           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7679
7680           printf (_("\nUnwind section "));
7681
7682           if (filedata->string_table == NULL)
7683             printf ("%d", unwsec->sh_name);
7684           else
7685             printf ("'%s'", printable_section_name (filedata, unwsec));
7686
7687           printf (_(" at offset 0x%lx contains %lu entries:\n"),
7688                   (unsigned long) unwsec->sh_offset,
7689                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7690
7691           if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
7692               && aux.table_len > 0)
7693             dump_ia64_unwind (filedata, & aux);
7694
7695           if (aux.table)
7696             free ((char *) aux.table);
7697           if (aux.info)
7698             free ((char *) aux.info);
7699           aux.table = NULL;
7700           aux.info = NULL;
7701         }
7702     }
7703
7704   if (aux.symtab)
7705     free (aux.symtab);
7706   if (aux.strtab)
7707     free ((char *) aux.strtab);
7708
7709   return res;
7710 }
7711
7712 struct hppa_unw_table_entry
7713 {
7714   struct absaddr start;
7715   struct absaddr end;
7716   unsigned int Cannot_unwind:1;                 /* 0 */
7717   unsigned int Millicode:1;                     /* 1 */
7718   unsigned int Millicode_save_sr0:1;            /* 2 */
7719   unsigned int Region_description:2;            /* 3..4 */
7720   unsigned int reserved1:1;                     /* 5 */
7721   unsigned int Entry_SR:1;                      /* 6 */
7722   unsigned int Entry_FR:4;     /* Number saved     7..10 */
7723   unsigned int Entry_GR:5;     /* Number saved     11..15 */
7724   unsigned int Args_stored:1;                   /* 16 */
7725   unsigned int Variable_Frame:1;                /* 17 */
7726   unsigned int Separate_Package_Body:1;         /* 18 */
7727   unsigned int Frame_Extension_Millicode:1;     /* 19 */
7728   unsigned int Stack_Overflow_Check:1;          /* 20 */
7729   unsigned int Two_Instruction_SP_Increment:1;  /* 21 */
7730   unsigned int Ada_Region:1;                    /* 22 */
7731   unsigned int cxx_info:1;                      /* 23 */
7732   unsigned int cxx_try_catch:1;                 /* 24 */
7733   unsigned int sched_entry_seq:1;               /* 25 */
7734   unsigned int reserved2:1;                     /* 26 */
7735   unsigned int Save_SP:1;                       /* 27 */
7736   unsigned int Save_RP:1;                       /* 28 */
7737   unsigned int Save_MRP_in_frame:1;             /* 29 */
7738   unsigned int extn_ptr_defined:1;              /* 30 */
7739   unsigned int Cleanup_defined:1;               /* 31 */
7740
7741   unsigned int MPE_XL_interrupt_marker:1;       /* 0 */
7742   unsigned int HP_UX_interrupt_marker:1;        /* 1 */
7743   unsigned int Large_frame:1;                   /* 2 */
7744   unsigned int Pseudo_SP_Set:1;                 /* 3 */
7745   unsigned int reserved4:1;                     /* 4 */
7746   unsigned int Total_frame_size:27;             /* 5..31 */
7747 };
7748
7749 struct hppa_unw_aux_info
7750 {
7751   struct hppa_unw_table_entry *  table;         /* Unwind table.  */
7752   unsigned long                  table_len;     /* Length of unwind table.  */
7753   bfd_vma                        seg_base;      /* Starting address of segment.  */
7754   Elf_Internal_Sym *             symtab;        /* The symbol table.  */
7755   unsigned long                  nsyms;         /* Number of symbols.  */
7756   Elf_Internal_Sym *             funtab;        /* Sorted table of STT_FUNC symbols.  */
7757   unsigned long                  nfuns;         /* Number of entries in funtab.  */
7758   char *                         strtab;        /* The string table.  */
7759   unsigned long                  strtab_size;   /* Size of string table.  */
7760 };
7761
7762 static bfd_boolean
7763 dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
7764 {
7765   struct hppa_unw_table_entry * tp;
7766   unsigned long j, nfuns;
7767   bfd_boolean res = TRUE;
7768
7769   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7770   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7771     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7772       aux->funtab[nfuns++] = aux->symtab[j];
7773   aux->nfuns = nfuns;
7774   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7775
7776   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7777     {
7778       bfd_vma offset;
7779       const char * procname;
7780
7781       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7782                                aux->strtab_size, tp->start, &procname,
7783                                &offset);
7784
7785       fputs ("\n<", stdout);
7786
7787       if (procname)
7788         {
7789           fputs (procname, stdout);
7790
7791           if (offset)
7792             printf ("+%lx", (unsigned long) offset);
7793         }
7794
7795       fputs (">: [", stdout);
7796       print_vma (tp->start.offset, PREFIX_HEX);
7797       fputc ('-', stdout);
7798       print_vma (tp->end.offset, PREFIX_HEX);
7799       printf ("]\n\t");
7800
7801 #define PF(_m) if (tp->_m) printf (#_m " ");
7802 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7803       PF(Cannot_unwind);
7804       PF(Millicode);
7805       PF(Millicode_save_sr0);
7806       /* PV(Region_description);  */
7807       PF(Entry_SR);
7808       PV(Entry_FR);
7809       PV(Entry_GR);
7810       PF(Args_stored);
7811       PF(Variable_Frame);
7812       PF(Separate_Package_Body);
7813       PF(Frame_Extension_Millicode);
7814       PF(Stack_Overflow_Check);
7815       PF(Two_Instruction_SP_Increment);
7816       PF(Ada_Region);
7817       PF(cxx_info);
7818       PF(cxx_try_catch);
7819       PF(sched_entry_seq);
7820       PF(Save_SP);
7821       PF(Save_RP);
7822       PF(Save_MRP_in_frame);
7823       PF(extn_ptr_defined);
7824       PF(Cleanup_defined);
7825       PF(MPE_XL_interrupt_marker);
7826       PF(HP_UX_interrupt_marker);
7827       PF(Large_frame);
7828       PF(Pseudo_SP_Set);
7829       PV(Total_frame_size);
7830 #undef PF
7831 #undef PV
7832     }
7833
7834   printf ("\n");
7835
7836   free (aux->funtab);
7837
7838   return res;
7839 }
7840
7841 static bfd_boolean
7842 slurp_hppa_unwind_table (Filedata *                  filedata,
7843                          struct hppa_unw_aux_info *  aux,
7844                          Elf_Internal_Shdr *         sec)
7845 {
7846   unsigned long size, unw_ent_size, nentries, nrelas, i;
7847   Elf_Internal_Phdr * seg;
7848   struct hppa_unw_table_entry * tep;
7849   Elf_Internal_Shdr * relsec;
7850   Elf_Internal_Rela * rela;
7851   Elf_Internal_Rela * rp;
7852   unsigned char * table;
7853   unsigned char * tp;
7854   Elf_Internal_Sym * sym;
7855   const char * relname;
7856
7857   /* First, find the starting address of the segment that includes
7858      this section.  */
7859   if (filedata->file_header.e_phnum)
7860     {
7861       if (! get_program_headers (filedata))
7862         return FALSE;
7863
7864       for (seg = filedata->program_headers;
7865            seg < filedata->program_headers + filedata->file_header.e_phnum;
7866            ++seg)
7867         {
7868           if (seg->p_type != PT_LOAD)
7869             continue;
7870
7871           if (sec->sh_addr >= seg->p_vaddr
7872               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7873             {
7874               aux->seg_base = seg->p_vaddr;
7875               break;
7876             }
7877         }
7878     }
7879
7880   /* Second, build the unwind table from the contents of the unwind
7881      section.  */
7882   size = sec->sh_size;
7883   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7884                                       _("unwind table"));
7885   if (!table)
7886     return FALSE;
7887
7888   unw_ent_size = 16;
7889   nentries = size / unw_ent_size;
7890   size = unw_ent_size * nentries;
7891
7892   tep = aux->table = (struct hppa_unw_table_entry *)
7893       xcmalloc (nentries, sizeof (aux->table[0]));
7894
7895   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7896     {
7897       unsigned int tmp1, tmp2;
7898
7899       tep->start.section = SHN_UNDEF;
7900       tep->end.section   = SHN_UNDEF;
7901
7902       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7903       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7904       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7905       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7906
7907       tep->start.offset += aux->seg_base;
7908       tep->end.offset   += aux->seg_base;
7909
7910       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7911       tep->Millicode = (tmp1 >> 30) & 0x1;
7912       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7913       tep->Region_description = (tmp1 >> 27) & 0x3;
7914       tep->reserved1 = (tmp1 >> 26) & 0x1;
7915       tep->Entry_SR = (tmp1 >> 25) & 0x1;
7916       tep->Entry_FR = (tmp1 >> 21) & 0xf;
7917       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7918       tep->Args_stored = (tmp1 >> 15) & 0x1;
7919       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7920       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7921       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7922       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7923       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7924       tep->Ada_Region = (tmp1 >> 9) & 0x1;
7925       tep->cxx_info = (tmp1 >> 8) & 0x1;
7926       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7927       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7928       tep->reserved2 = (tmp1 >> 5) & 0x1;
7929       tep->Save_SP = (tmp1 >> 4) & 0x1;
7930       tep->Save_RP = (tmp1 >> 3) & 0x1;
7931       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7932       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7933       tep->Cleanup_defined = tmp1 & 0x1;
7934
7935       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7936       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7937       tep->Large_frame = (tmp2 >> 29) & 0x1;
7938       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7939       tep->reserved4 = (tmp2 >> 27) & 0x1;
7940       tep->Total_frame_size = tmp2 & 0x7ffffff;
7941     }
7942   free (table);
7943
7944   /* Third, apply any relocations to the unwind table.  */
7945   for (relsec = filedata->section_headers;
7946        relsec < filedata->section_headers + filedata->file_header.e_shnum;
7947        ++relsec)
7948     {
7949       if (relsec->sh_type != SHT_RELA
7950           || relsec->sh_info >= filedata->file_header.e_shnum
7951           || filedata->section_headers + relsec->sh_info != sec)
7952         continue;
7953
7954       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7955                               & rela, & nrelas))
7956         return FALSE;
7957
7958       for (rp = rela; rp < rela + nrelas; ++rp)
7959         {
7960           relname = elf_hppa_reloc_type (get_reloc_type (filedata, rp->r_info));
7961           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7962
7963           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
7964           if (! const_strneq (relname, "R_PARISC_SEGREL"))
7965             {
7966               warn (_("Skipping unexpected relocation type %s\n"), relname);
7967               continue;
7968             }
7969
7970           i = rp->r_offset / unw_ent_size;
7971
7972           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
7973             {
7974             case 0:
7975               aux->table[i].start.section = sym->st_shndx;
7976               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
7977               break;
7978             case 1:
7979               aux->table[i].end.section   = sym->st_shndx;
7980               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
7981               break;
7982             default:
7983               break;
7984             }
7985         }
7986
7987       free (rela);
7988     }
7989
7990   aux->table_len = nentries;
7991
7992   return TRUE;
7993 }
7994
7995 static bfd_boolean
7996 hppa_process_unwind (Filedata * filedata)
7997 {
7998   struct hppa_unw_aux_info aux;
7999   Elf_Internal_Shdr * unwsec = NULL;
8000   Elf_Internal_Shdr * strsec;
8001   Elf_Internal_Shdr * sec;
8002   unsigned long i;
8003   bfd_boolean res = TRUE;
8004
8005   if (filedata->string_table == NULL)
8006     return FALSE;
8007
8008   memset (& aux, 0, sizeof (aux));
8009
8010   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8011     {
8012       if (sec->sh_type == SHT_SYMTAB
8013           && sec->sh_link < filedata->file_header.e_shnum)
8014         {
8015           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
8016
8017           strsec = filedata->section_headers + sec->sh_link;
8018           if (aux.strtab != NULL)
8019             {
8020               error (_("Multiple auxillary string tables encountered\n"));
8021               free (aux.strtab);
8022               res = FALSE;
8023             }
8024           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
8025                                           1, strsec->sh_size,
8026                                           _("string table"));
8027           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8028         }
8029       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8030         unwsec = sec;
8031     }
8032
8033   if (!unwsec)
8034     printf (_("\nThere are no unwind sections in this file.\n"));
8035
8036   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8037     {
8038       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8039         {
8040           unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size + 8);
8041
8042           printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8043                             "contains %lu entry:\n",
8044                             "\nUnwind section '%s' at offset 0x%lx "
8045                             "contains %lu entries:\n",
8046                             num_unwind),
8047                   printable_section_name (filedata, sec),
8048                   (unsigned long) sec->sh_offset,
8049                   num_unwind);
8050
8051           if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8052             res = FALSE;
8053
8054           if (aux.table_len > 0)
8055             {
8056               if (! dump_hppa_unwind (filedata, &aux))
8057                 res = FALSE;
8058             }
8059
8060           if (aux.table)
8061             free ((char *) aux.table);
8062           aux.table = NULL;
8063         }
8064     }
8065
8066   if (aux.symtab)
8067     free (aux.symtab);
8068   if (aux.strtab)
8069     free ((char *) aux.strtab);
8070
8071   return res;
8072 }
8073
8074 struct arm_section
8075 {
8076   unsigned char *      data;            /* The unwind data.  */
8077   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
8078   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
8079   unsigned long        nrelas;          /* The number of relocations.  */
8080   unsigned int         rel_type;        /* REL or RELA ?  */
8081   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
8082 };
8083
8084 struct arm_unw_aux_info
8085 {
8086   Filedata *          filedata;         /* The file containing the unwind sections.  */
8087   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
8088   unsigned long       nsyms;            /* Number of symbols.  */
8089   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
8090   unsigned long       nfuns;            /* Number of these symbols.  */
8091   char *              strtab;           /* The file's string table.  */
8092   unsigned long       strtab_size;      /* Size of string table.  */
8093 };
8094
8095 static const char *
8096 arm_print_vma_and_name (Filedata *                 filedata,
8097                         struct arm_unw_aux_info *  aux,
8098                         bfd_vma                    fn,
8099                         struct absaddr             addr)
8100 {
8101   const char *procname;
8102   bfd_vma sym_offset;
8103
8104   if (addr.section == SHN_UNDEF)
8105     addr.offset = fn;
8106
8107   find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8108                            aux->strtab_size, addr, &procname,
8109                            &sym_offset);
8110
8111   print_vma (fn, PREFIX_HEX);
8112
8113   if (procname)
8114     {
8115       fputs (" <", stdout);
8116       fputs (procname, stdout);
8117
8118       if (sym_offset)
8119         printf ("+0x%lx", (unsigned long) sym_offset);
8120       fputc ('>', stdout);
8121     }
8122
8123   return procname;
8124 }
8125
8126 static void
8127 arm_free_section (struct arm_section *arm_sec)
8128 {
8129   if (arm_sec->data != NULL)
8130     free (arm_sec->data);
8131
8132   if (arm_sec->rela != NULL)
8133     free (arm_sec->rela);
8134 }
8135
8136 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8137       cached section and install SEC instead.
8138    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8139       and return its valued in * WORDP, relocating if necessary.
8140    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8141       relocation's offset in ADDR.
8142    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8143       into the string table of the symbol associated with the reloc.  If no
8144       reloc was applied store -1 there.
8145    5) Return TRUE upon success, FALSE otherwise.  */
8146
8147 static bfd_boolean
8148 get_unwind_section_word (Filedata *                 filedata,
8149                          struct arm_unw_aux_info *  aux,
8150                          struct arm_section *       arm_sec,
8151                          Elf_Internal_Shdr *        sec,
8152                          bfd_vma                    word_offset,
8153                          unsigned int *             wordp,
8154                          struct absaddr *           addr,
8155                          bfd_vma *                  sym_name)
8156 {
8157   Elf_Internal_Rela *rp;
8158   Elf_Internal_Sym *sym;
8159   const char * relname;
8160   unsigned int word;
8161   bfd_boolean wrapped;
8162
8163   if (sec == NULL || arm_sec == NULL)
8164     return FALSE;
8165
8166   addr->section = SHN_UNDEF;
8167   addr->offset = 0;
8168
8169   if (sym_name != NULL)
8170     *sym_name = (bfd_vma) -1;
8171
8172   /* If necessary, update the section cache.  */
8173   if (sec != arm_sec->sec)
8174     {
8175       Elf_Internal_Shdr *relsec;
8176
8177       arm_free_section (arm_sec);
8178
8179       arm_sec->sec = sec;
8180       arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8181                                 sec->sh_size, _("unwind data"));
8182       arm_sec->rela = NULL;
8183       arm_sec->nrelas = 0;
8184
8185       for (relsec = filedata->section_headers;
8186            relsec < filedata->section_headers + filedata->file_header.e_shnum;
8187            ++relsec)
8188         {
8189           if (relsec->sh_info >= filedata->file_header.e_shnum
8190               || filedata->section_headers + relsec->sh_info != sec
8191               /* PR 15745: Check the section type as well.  */
8192               || (relsec->sh_type != SHT_REL
8193                   && relsec->sh_type != SHT_RELA))
8194             continue;
8195
8196           arm_sec->rel_type = relsec->sh_type;
8197           if (relsec->sh_type == SHT_REL)
8198             {
8199               if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8200                                      relsec->sh_size,
8201                                      & arm_sec->rela, & arm_sec->nrelas))
8202                 return FALSE;
8203             }
8204           else /* relsec->sh_type == SHT_RELA */
8205             {
8206               if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8207                                       relsec->sh_size,
8208                                       & arm_sec->rela, & arm_sec->nrelas))
8209                 return FALSE;
8210             }
8211           break;
8212         }
8213
8214       arm_sec->next_rela = arm_sec->rela;
8215     }
8216
8217   /* If there is no unwind data we can do nothing.  */
8218   if (arm_sec->data == NULL)
8219     return FALSE;
8220
8221   /* If the offset is invalid then fail.  */
8222   if (/* PR 21343 *//* PR 18879 */
8223       sec->sh_size < 4
8224       || word_offset > (sec->sh_size - 4)
8225       || ((bfd_signed_vma) word_offset) < 0)
8226     return FALSE;
8227
8228   /* Get the word at the required offset.  */
8229   word = byte_get (arm_sec->data + word_offset, 4);
8230
8231   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
8232   if (arm_sec->rela == NULL)
8233     {
8234       * wordp = word;
8235       return TRUE;
8236     }
8237
8238   /* Look through the relocs to find the one that applies to the provided offset.  */
8239   wrapped = FALSE;
8240   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8241     {
8242       bfd_vma prelval, offset;
8243
8244       if (rp->r_offset > word_offset && !wrapped)
8245         {
8246           rp = arm_sec->rela;
8247           wrapped = TRUE;
8248         }
8249       if (rp->r_offset > word_offset)
8250         break;
8251
8252       if (rp->r_offset & 3)
8253         {
8254           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8255                 (unsigned long) rp->r_offset);
8256           continue;
8257         }
8258
8259       if (rp->r_offset < word_offset)
8260         continue;
8261
8262       /* PR 17531: file: 027-161405-0.004  */
8263       if (aux->symtab == NULL)
8264         continue;
8265
8266       if (arm_sec->rel_type == SHT_REL)
8267         {
8268           offset = word & 0x7fffffff;
8269           if (offset & 0x40000000)
8270             offset |= ~ (bfd_vma) 0x7fffffff;
8271         }
8272       else if (arm_sec->rel_type == SHT_RELA)
8273         offset = rp->r_addend;
8274       else
8275         {
8276           error (_("Unknown section relocation type %d encountered\n"),
8277                  arm_sec->rel_type);
8278           break;
8279         }
8280
8281       /* PR 17531 file: 027-1241568-0.004.  */
8282       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8283         {
8284           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8285                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8286           break;
8287         }
8288
8289       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8290       offset += sym->st_value;
8291       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8292
8293       /* Check that we are processing the expected reloc type.  */
8294       if (filedata->file_header.e_machine == EM_ARM)
8295         {
8296           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8297           if (relname == NULL)
8298             {
8299               warn (_("Skipping unknown ARM relocation type: %d\n"),
8300                     (int) ELF32_R_TYPE (rp->r_info));
8301               continue;
8302             }
8303
8304           if (streq (relname, "R_ARM_NONE"))
8305               continue;
8306
8307           if (! streq (relname, "R_ARM_PREL31"))
8308             {
8309               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8310               continue;
8311             }
8312         }
8313       else if (filedata->file_header.e_machine == EM_TI_C6000)
8314         {
8315           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8316           if (relname == NULL)
8317             {
8318               warn (_("Skipping unknown C6000 relocation type: %d\n"),
8319                     (int) ELF32_R_TYPE (rp->r_info));
8320               continue;
8321             }
8322
8323           if (streq (relname, "R_C6000_NONE"))
8324             continue;
8325
8326           if (! streq (relname, "R_C6000_PREL31"))
8327             {
8328               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8329               continue;
8330             }
8331
8332           prelval >>= 1;
8333         }
8334       else
8335         {
8336           /* This function currently only supports ARM and TI unwinders.  */
8337           warn (_("Only TI and ARM unwinders are currently supported\n"));
8338           break;
8339         }
8340
8341       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8342       addr->section = sym->st_shndx;
8343       addr->offset = offset;
8344
8345       if (sym_name)
8346         * sym_name = sym->st_name;
8347       break;
8348     }
8349
8350   *wordp = word;
8351   arm_sec->next_rela = rp;
8352
8353   return TRUE;
8354 }
8355
8356 static const char *tic6x_unwind_regnames[16] =
8357 {
8358   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8359   "A14", "A13", "A12", "A11", "A10",
8360   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8361 };
8362
8363 static void
8364 decode_tic6x_unwind_regmask (unsigned int mask)
8365 {
8366   int i;
8367
8368   for (i = 12; mask; mask >>= 1, i--)
8369     {
8370       if (mask & 1)
8371         {
8372           fputs (tic6x_unwind_regnames[i], stdout);
8373           if (mask > 1)
8374             fputs (", ", stdout);
8375         }
8376     }
8377 }
8378
8379 #define ADVANCE                                                 \
8380   if (remaining == 0 && more_words)                             \
8381     {                                                           \
8382       data_offset += 4;                                         \
8383       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec,     \
8384                                      data_offset, & word, & addr, NULL))        \
8385         return FALSE;                                           \
8386       remaining = 4;                                            \
8387       more_words--;                                             \
8388     }                                                           \
8389
8390 #define GET_OP(OP)                      \
8391   ADVANCE;                              \
8392   if (remaining)                        \
8393     {                                   \
8394       remaining--;                      \
8395       (OP) = word >> 24;                \
8396       word <<= 8;                       \
8397     }                                   \
8398   else                                  \
8399     {                                   \
8400       printf (_("[Truncated opcode]\n"));       \
8401       return FALSE;                     \
8402     }                                   \
8403   printf ("0x%02x ", OP)
8404
8405 static bfd_boolean
8406 decode_arm_unwind_bytecode (Filedata *                 filedata,
8407                             struct arm_unw_aux_info *  aux,
8408                             unsigned int               word,
8409                             unsigned int               remaining,
8410                             unsigned int               more_words,
8411                             bfd_vma                    data_offset,
8412                             Elf_Internal_Shdr *        data_sec,
8413                             struct arm_section *       data_arm_sec)
8414 {
8415   struct absaddr addr;
8416   bfd_boolean res = TRUE;
8417
8418   /* Decode the unwinding instructions.  */
8419   while (1)
8420     {
8421       unsigned int op, op2;
8422
8423       ADVANCE;
8424       if (remaining == 0)
8425         break;
8426       remaining--;
8427       op = word >> 24;
8428       word <<= 8;
8429
8430       printf ("  0x%02x ", op);
8431
8432       if ((op & 0xc0) == 0x00)
8433         {
8434           int offset = ((op & 0x3f) << 2) + 4;
8435
8436           printf ("     vsp = vsp + %d", offset);
8437         }
8438       else if ((op & 0xc0) == 0x40)
8439         {
8440           int offset = ((op & 0x3f) << 2) + 4;
8441
8442           printf ("     vsp = vsp - %d", offset);
8443         }
8444       else if ((op & 0xf0) == 0x80)
8445         {
8446           GET_OP (op2);
8447           if (op == 0x80 && op2 == 0)
8448             printf (_("Refuse to unwind"));
8449           else
8450             {
8451               unsigned int mask = ((op & 0x0f) << 8) | op2;
8452               bfd_boolean first = TRUE;
8453               int i;
8454
8455               printf ("pop {");
8456               for (i = 0; i < 12; i++)
8457                 if (mask & (1 << i))
8458                   {
8459                     if (first)
8460                       first = FALSE;
8461                     else
8462                       printf (", ");
8463                     printf ("r%d", 4 + i);
8464                   }
8465               printf ("}");
8466             }
8467         }
8468       else if ((op & 0xf0) == 0x90)
8469         {
8470           if (op == 0x9d || op == 0x9f)
8471             printf (_("     [Reserved]"));
8472           else
8473             printf ("     vsp = r%d", op & 0x0f);
8474         }
8475       else if ((op & 0xf0) == 0xa0)
8476         {
8477           int end = 4 + (op & 0x07);
8478           bfd_boolean first = TRUE;
8479           int i;
8480
8481           printf ("     pop {");
8482           for (i = 4; i <= end; i++)
8483             {
8484               if (first)
8485                 first = FALSE;
8486               else
8487                 printf (", ");
8488               printf ("r%d", i);
8489             }
8490           if (op & 0x08)
8491             {
8492               if (!first)
8493                 printf (", ");
8494               printf ("r14");
8495             }
8496           printf ("}");
8497         }
8498       else if (op == 0xb0)
8499         printf (_("     finish"));
8500       else if (op == 0xb1)
8501         {
8502           GET_OP (op2);
8503           if (op2 == 0 || (op2 & 0xf0) != 0)
8504             printf (_("[Spare]"));
8505           else
8506             {
8507               unsigned int mask = op2 & 0x0f;
8508               bfd_boolean first = TRUE;
8509               int i;
8510
8511               printf ("pop {");
8512               for (i = 0; i < 12; i++)
8513                 if (mask & (1 << i))
8514                   {
8515                     if (first)
8516                       first = FALSE;
8517                     else
8518                       printf (", ");
8519                     printf ("r%d", i);
8520                   }
8521               printf ("}");
8522             }
8523         }
8524       else if (op == 0xb2)
8525         {
8526           unsigned char buf[9];
8527           unsigned int i, len;
8528           unsigned long offset;
8529
8530           for (i = 0; i < sizeof (buf); i++)
8531             {
8532               GET_OP (buf[i]);
8533               if ((buf[i] & 0x80) == 0)
8534                 break;
8535             }
8536           if (i == sizeof (buf))
8537             {
8538               error (_("corrupt change to vsp"));
8539               res = FALSE;
8540             }
8541           else
8542             {
8543               offset = read_uleb128 (buf, &len, buf + i + 1);
8544               assert (len == i + 1);
8545               offset = offset * 4 + 0x204;
8546               printf ("vsp = vsp + %ld", offset);
8547             }
8548         }
8549       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8550         {
8551           unsigned int first, last;
8552
8553           GET_OP (op2);
8554           first = op2 >> 4;
8555           last = op2 & 0x0f;
8556           if (op == 0xc8)
8557             first = first + 16;
8558           printf ("pop {D%d", first);
8559           if (last)
8560             printf ("-D%d", first + last);
8561           printf ("}");
8562         }
8563       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8564         {
8565           unsigned int count = op & 0x07;
8566
8567           printf ("pop {D8");
8568           if (count)
8569             printf ("-D%d", 8 + count);
8570           printf ("}");
8571         }
8572       else if (op >= 0xc0 && op <= 0xc5)
8573         {
8574           unsigned int count = op & 0x07;
8575
8576           printf ("     pop {wR10");
8577           if (count)
8578             printf ("-wR%d", 10 + count);
8579           printf ("}");
8580         }
8581       else if (op == 0xc6)
8582         {
8583           unsigned int first, last;
8584
8585           GET_OP (op2);
8586           first = op2 >> 4;
8587           last = op2 & 0x0f;
8588           printf ("pop {wR%d", first);
8589           if (last)
8590             printf ("-wR%d", first + last);
8591           printf ("}");
8592         }
8593       else if (op == 0xc7)
8594         {
8595           GET_OP (op2);
8596           if (op2 == 0 || (op2 & 0xf0) != 0)
8597             printf (_("[Spare]"));
8598           else
8599             {
8600               unsigned int mask = op2 & 0x0f;
8601               bfd_boolean first = TRUE;
8602               int i;
8603
8604               printf ("pop {");
8605               for (i = 0; i < 4; i++)
8606                 if (mask & (1 << i))
8607                   {
8608                     if (first)
8609                       first = FALSE;
8610                     else
8611                       printf (", ");
8612                     printf ("wCGR%d", i);
8613                   }
8614               printf ("}");
8615             }
8616         }
8617       else
8618         {
8619           printf (_("     [unsupported opcode]"));
8620           res = FALSE;
8621         }
8622
8623       printf ("\n");
8624     }
8625
8626   return res;
8627 }
8628
8629 static bfd_boolean
8630 decode_tic6x_unwind_bytecode (Filedata *                 filedata,
8631                               struct arm_unw_aux_info *  aux,
8632                               unsigned int               word,
8633                               unsigned int               remaining,
8634                               unsigned int               more_words,
8635                               bfd_vma                    data_offset,
8636                               Elf_Internal_Shdr *        data_sec,
8637                               struct arm_section *       data_arm_sec)
8638 {
8639   struct absaddr addr;
8640
8641   /* Decode the unwinding instructions.  */
8642   while (1)
8643     {
8644       unsigned int op, op2;
8645
8646       ADVANCE;
8647       if (remaining == 0)
8648         break;
8649       remaining--;
8650       op = word >> 24;
8651       word <<= 8;
8652
8653       printf ("  0x%02x ", op);
8654
8655       if ((op & 0xc0) == 0x00)
8656         {
8657           int offset = ((op & 0x3f) << 3) + 8;
8658           printf ("     sp = sp + %d", offset);
8659         }
8660       else if ((op & 0xc0) == 0x80)
8661         {
8662           GET_OP (op2);
8663           if (op == 0x80 && op2 == 0)
8664             printf (_("Refuse to unwind"));
8665           else
8666             {
8667               unsigned int mask = ((op & 0x1f) << 8) | op2;
8668               if (op & 0x20)
8669                 printf ("pop compact {");
8670               else
8671                 printf ("pop {");
8672
8673               decode_tic6x_unwind_regmask (mask);
8674               printf("}");
8675             }
8676         }
8677       else if ((op & 0xf0) == 0xc0)
8678         {
8679           unsigned int reg;
8680           unsigned int nregs;
8681           unsigned int i;
8682           const char *name;
8683           struct
8684           {
8685             unsigned int offset;
8686             unsigned int reg;
8687           } regpos[16];
8688
8689           /* Scan entire instruction first so that GET_OP output is not
8690              interleaved with disassembly.  */
8691           nregs = 0;
8692           for (i = 0; nregs < (op & 0xf); i++)
8693             {
8694               GET_OP (op2);
8695               reg = op2 >> 4;
8696               if (reg != 0xf)
8697                 {
8698                   regpos[nregs].offset = i * 2;
8699                   regpos[nregs].reg = reg;
8700                   nregs++;
8701                 }
8702
8703               reg = op2 & 0xf;
8704               if (reg != 0xf)
8705                 {
8706                   regpos[nregs].offset = i * 2 + 1;
8707                   regpos[nregs].reg = reg;
8708                   nregs++;
8709                 }
8710             }
8711
8712           printf (_("pop frame {"));
8713           reg = nregs - 1;
8714           for (i = i * 2; i > 0; i--)
8715             {
8716               if (regpos[reg].offset == i - 1)
8717                 {
8718                   name = tic6x_unwind_regnames[regpos[reg].reg];
8719                   if (reg > 0)
8720                     reg--;
8721                 }
8722               else
8723                 name = _("[pad]");
8724
8725               fputs (name, stdout);
8726               if (i > 1)
8727                 printf (", ");
8728             }
8729
8730           printf ("}");
8731         }
8732       else if (op == 0xd0)
8733         printf ("     MOV FP, SP");
8734       else if (op == 0xd1)
8735         printf ("     __c6xabi_pop_rts");
8736       else if (op == 0xd2)
8737         {
8738           unsigned char buf[9];
8739           unsigned int i, len;
8740           unsigned long offset;
8741
8742           for (i = 0; i < sizeof (buf); i++)
8743             {
8744               GET_OP (buf[i]);
8745               if ((buf[i] & 0x80) == 0)
8746                 break;
8747             }
8748           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8749           if (i == sizeof (buf))
8750             {
8751               warn (_("Corrupt stack pointer adjustment detected\n"));
8752               return FALSE;
8753             }
8754
8755           offset = read_uleb128 (buf, &len, buf + i + 1);
8756           assert (len == i + 1);
8757           offset = offset * 8 + 0x408;
8758           printf (_("sp = sp + %ld"), offset);
8759         }
8760       else if ((op & 0xf0) == 0xe0)
8761         {
8762           if ((op & 0x0f) == 7)
8763             printf ("     RETURN");
8764           else
8765             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8766         }
8767       else
8768         {
8769           printf (_("     [unsupported opcode]"));
8770         }
8771       putchar ('\n');
8772     }
8773
8774   return TRUE;
8775 }
8776
8777 static bfd_vma
8778 arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
8779 {
8780   bfd_vma offset;
8781
8782   offset = word & 0x7fffffff;
8783   if (offset & 0x40000000)
8784     offset |= ~ (bfd_vma) 0x7fffffff;
8785
8786   if (filedata->file_header.e_machine == EM_TI_C6000)
8787     offset <<= 1;
8788
8789   return offset + where;
8790 }
8791
8792 static bfd_boolean
8793 decode_arm_unwind (Filedata *                 filedata,
8794                    struct arm_unw_aux_info *  aux,
8795                    unsigned int               word,
8796                    unsigned int               remaining,
8797                    bfd_vma                    data_offset,
8798                    Elf_Internal_Shdr *        data_sec,
8799                    struct arm_section *       data_arm_sec)
8800 {
8801   int per_index;
8802   unsigned int more_words = 0;
8803   struct absaddr addr;
8804   bfd_vma sym_name = (bfd_vma) -1;
8805   bfd_boolean res = TRUE;
8806
8807   if (remaining == 0)
8808     {
8809       /* Fetch the first word.
8810          Note - when decoding an object file the address extracted
8811          here will always be 0.  So we also pass in the sym_name
8812          parameter so that we can find the symbol associated with
8813          the personality routine.  */
8814       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
8815                                      & word, & addr, & sym_name))
8816         return FALSE;
8817
8818       remaining = 4;
8819     }
8820
8821   if ((word & 0x80000000) == 0)
8822     {
8823       /* Expand prel31 for personality routine.  */
8824       bfd_vma fn;
8825       const char *procname;
8826
8827       fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
8828       printf (_("  Personality routine: "));
8829       if (fn == 0
8830           && addr.section == SHN_UNDEF && addr.offset == 0
8831           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8832         {
8833           procname = aux->strtab + sym_name;
8834           print_vma (fn, PREFIX_HEX);
8835           if (procname)
8836             {
8837               fputs (" <", stdout);
8838               fputs (procname, stdout);
8839               fputc ('>', stdout);
8840             }
8841         }
8842       else
8843         procname = arm_print_vma_and_name (filedata, aux, fn, addr);
8844       fputc ('\n', stdout);
8845
8846       /* The GCC personality routines use the standard compact
8847          encoding, starting with one byte giving the number of
8848          words.  */
8849       if (procname != NULL
8850           && (const_strneq (procname, "__gcc_personality_v0")
8851               || const_strneq (procname, "__gxx_personality_v0")
8852               || const_strneq (procname, "__gcj_personality_v0")
8853               || const_strneq (procname, "__gnu_objc_personality_v0")))
8854         {
8855           remaining = 0;
8856           more_words = 1;
8857           ADVANCE;
8858           if (!remaining)
8859             {
8860               printf (_("  [Truncated data]\n"));
8861               return FALSE;
8862             }
8863           more_words = word >> 24;
8864           word <<= 8;
8865           remaining--;
8866           per_index = -1;
8867         }
8868       else
8869         return TRUE;
8870     }
8871   else
8872     {
8873       /* ARM EHABI Section 6.3:
8874
8875          An exception-handling table entry for the compact model looks like:
8876
8877            31 30-28 27-24 23-0
8878            -- ----- ----- ----
8879             1   0   index Data for personalityRoutine[index]    */
8880
8881       if (filedata->file_header.e_machine == EM_ARM
8882           && (word & 0x70000000))
8883         {
8884           warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8885           res = FALSE;
8886         }
8887
8888       per_index = (word >> 24) & 0x7f;
8889       printf (_("  Compact model index: %d\n"), per_index);
8890       if (per_index == 0)
8891         {
8892           more_words = 0;
8893           word <<= 8;
8894           remaining--;
8895         }
8896       else if (per_index < 3)
8897         {
8898           more_words = (word >> 16) & 0xff;
8899           word <<= 16;
8900           remaining -= 2;
8901         }
8902     }
8903
8904   switch (filedata->file_header.e_machine)
8905     {
8906     case EM_ARM:
8907       if (per_index < 3)
8908         {
8909           if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
8910                                             data_offset, data_sec, data_arm_sec))
8911             res = FALSE;
8912         }
8913       else
8914         {
8915           warn (_("Unknown ARM compact model index encountered\n"));
8916           printf (_("  [reserved]\n"));
8917           res = FALSE;
8918         }
8919       break;
8920
8921     case EM_TI_C6000:
8922       if (per_index < 3)
8923         {
8924           if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
8925                                               data_offset, data_sec, data_arm_sec))
8926             res = FALSE;
8927         }
8928       else if (per_index < 5)
8929         {
8930           if (((word >> 17) & 0x7f) == 0x7f)
8931             printf (_("  Restore stack from frame pointer\n"));
8932           else
8933             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
8934           printf (_("  Registers restored: "));
8935           if (per_index == 4)
8936             printf (" (compact) ");
8937           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8938           putchar ('\n');
8939           printf (_("  Return register: %s\n"),
8940                   tic6x_unwind_regnames[word & 0xf]);
8941         }
8942       else
8943         printf (_("  [reserved (%d)]\n"), per_index);
8944       break;
8945
8946     default:
8947       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8948              filedata->file_header.e_machine);
8949       res = FALSE;
8950     }
8951
8952   /* Decode the descriptors.  Not implemented.  */
8953
8954   return res;
8955 }
8956
8957 static bfd_boolean
8958 dump_arm_unwind (Filedata *                 filedata,
8959                  struct arm_unw_aux_info *  aux,
8960                  Elf_Internal_Shdr *        exidx_sec)
8961 {
8962   struct arm_section exidx_arm_sec, extab_arm_sec;
8963   unsigned int i, exidx_len;
8964   unsigned long j, nfuns;
8965   bfd_boolean res = TRUE;
8966
8967   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8968   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8969   exidx_len = exidx_sec->sh_size / 8;
8970
8971   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8972   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8973     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8974       aux->funtab[nfuns++] = aux->symtab[j];
8975   aux->nfuns = nfuns;
8976   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8977
8978   for (i = 0; i < exidx_len; i++)
8979     {
8980       unsigned int exidx_fn, exidx_entry;
8981       struct absaddr fn_addr, entry_addr;
8982       bfd_vma fn;
8983
8984       fputc ('\n', stdout);
8985
8986       if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
8987                                      8 * i, & exidx_fn, & fn_addr, NULL)
8988           || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
8989                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
8990         {
8991           free (aux->funtab);
8992           arm_free_section (& exidx_arm_sec);
8993           arm_free_section (& extab_arm_sec);
8994           return FALSE;
8995         }
8996
8997       /* ARM EHABI, Section 5:
8998          An index table entry consists of 2 words.
8999          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
9000       if (exidx_fn & 0x80000000)
9001         {
9002           warn (_("corrupt index table entry: %x\n"), exidx_fn);
9003           res = FALSE;
9004         }
9005
9006       fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9007
9008       arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9009       fputs (": ", stdout);
9010
9011       if (exidx_entry == 1)
9012         {
9013           print_vma (exidx_entry, PREFIX_HEX);
9014           fputs (" [cantunwind]\n", stdout);
9015         }
9016       else if (exidx_entry & 0x80000000)
9017         {
9018           print_vma (exidx_entry, PREFIX_HEX);
9019           fputc ('\n', stdout);
9020           decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9021         }
9022       else
9023         {
9024           bfd_vma table, table_offset = 0;
9025           Elf_Internal_Shdr *table_sec;
9026
9027           fputs ("@", stdout);
9028           table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9029           print_vma (table, PREFIX_HEX);
9030           printf ("\n");
9031
9032           /* Locate the matching .ARM.extab.  */
9033           if (entry_addr.section != SHN_UNDEF
9034               && entry_addr.section < filedata->file_header.e_shnum)
9035             {
9036               table_sec = filedata->section_headers + entry_addr.section;
9037               table_offset = entry_addr.offset;
9038               /* PR 18879 */
9039               if (table_offset > table_sec->sh_size
9040                   || ((bfd_signed_vma) table_offset) < 0)
9041                 {
9042                   warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9043                         (unsigned long) table_offset,
9044                         printable_section_name (filedata, table_sec));
9045                   res = FALSE;
9046                   continue;
9047                 }
9048             }
9049           else
9050             {
9051               table_sec = find_section_by_address (filedata, table);
9052               if (table_sec != NULL)
9053                 table_offset = table - table_sec->sh_addr;
9054             }
9055
9056           if (table_sec == NULL)
9057             {
9058               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9059                     (unsigned long) table);
9060               res = FALSE;
9061               continue;
9062             }
9063
9064           if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9065                                    &extab_arm_sec))
9066             res = FALSE;
9067         }
9068     }
9069
9070   printf ("\n");
9071
9072   free (aux->funtab);
9073   arm_free_section (&exidx_arm_sec);
9074   arm_free_section (&extab_arm_sec);
9075
9076   return res;
9077 }
9078
9079 /* Used for both ARM and C6X unwinding tables.  */
9080
9081 static bfd_boolean
9082 arm_process_unwind (Filedata * filedata)
9083 {
9084   struct arm_unw_aux_info aux;
9085   Elf_Internal_Shdr *unwsec = NULL;
9086   Elf_Internal_Shdr *strsec;
9087   Elf_Internal_Shdr *sec;
9088   unsigned long i;
9089   unsigned int sec_type;
9090   bfd_boolean res = TRUE;
9091
9092   switch (filedata->file_header.e_machine)
9093     {
9094     case EM_ARM:
9095       sec_type = SHT_ARM_EXIDX;
9096       break;
9097
9098     case EM_TI_C6000:
9099       sec_type = SHT_C6000_UNWIND;
9100       break;
9101
9102     default:
9103       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9104              filedata->file_header.e_machine);
9105       return FALSE;
9106     }
9107
9108   if (filedata->string_table == NULL)
9109     return FALSE;
9110
9111   memset (& aux, 0, sizeof (aux));
9112   aux.filedata = filedata;
9113
9114   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9115     {
9116       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < filedata->file_header.e_shnum)
9117         {
9118           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
9119
9120           strsec = filedata->section_headers + sec->sh_link;
9121
9122           /* PR binutils/17531 file: 011-12666-0.004.  */
9123           if (aux.strtab != NULL)
9124             {
9125               error (_("Multiple string tables found in file.\n"));
9126               free (aux.strtab);
9127               res = FALSE;
9128             }
9129           aux.strtab = get_data (NULL, filedata, strsec->sh_offset,
9130                                  1, strsec->sh_size, _("string table"));
9131           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9132         }
9133       else if (sec->sh_type == sec_type)
9134         unwsec = sec;
9135     }
9136
9137   if (unwsec == NULL)
9138     printf (_("\nThere are no unwind sections in this file.\n"));
9139   else
9140     for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9141       {
9142         if (sec->sh_type == sec_type)
9143           {
9144             unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9145             printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9146                               "contains %lu entry:\n",
9147                               "\nUnwind section '%s' at offset 0x%lx "
9148                               "contains %lu entries:\n",
9149                               num_unwind),
9150                     printable_section_name (filedata, sec),
9151                     (unsigned long) sec->sh_offset,
9152                     num_unwind);
9153
9154             if (! dump_arm_unwind (filedata, &aux, sec))
9155               res = FALSE;
9156           }
9157       }
9158
9159   if (aux.symtab)
9160     free (aux.symtab);
9161   if (aux.strtab)
9162     free ((char *) aux.strtab);
9163
9164   return res;
9165 }
9166
9167 static bfd_boolean
9168 process_unwind (Filedata * filedata)
9169 {
9170   struct unwind_handler
9171   {
9172     unsigned int machtype;
9173     bfd_boolean (* handler)(Filedata *);
9174   } handlers[] =
9175   {
9176     { EM_ARM, arm_process_unwind },
9177     { EM_IA_64, ia64_process_unwind },
9178     { EM_PARISC, hppa_process_unwind },
9179     { EM_TI_C6000, arm_process_unwind },
9180     { 0, NULL }
9181   };
9182   int i;
9183
9184   if (!do_unwind)
9185     return TRUE;
9186
9187   for (i = 0; handlers[i].handler != NULL; i++)
9188     if (filedata->file_header.e_machine == handlers[i].machtype)
9189       return handlers[i].handler (filedata);
9190
9191   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9192           get_machine_name (filedata->file_header.e_machine));
9193   return TRUE;
9194 }
9195
9196 static void
9197 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9198 {
9199   switch (entry->d_tag)
9200     {
9201     case DT_MIPS_FLAGS:
9202       if (entry->d_un.d_val == 0)
9203         printf (_("NONE"));
9204       else
9205         {
9206           static const char * opts[] =
9207           {
9208             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9209             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9210             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9211             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9212             "RLD_ORDER_SAFE"
9213           };
9214           unsigned int cnt;
9215           bfd_boolean first = TRUE;
9216
9217           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9218             if (entry->d_un.d_val & (1 << cnt))
9219               {
9220                 printf ("%s%s", first ? "" : " ", opts[cnt]);
9221                 first = FALSE;
9222               }
9223         }
9224       break;
9225
9226     case DT_MIPS_IVERSION:
9227       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9228         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9229       else
9230         {
9231           char buf[40];
9232           sprintf_vma (buf, entry->d_un.d_ptr);
9233           /* Note: coded this way so that there is a single string for translation.  */
9234           printf (_("<corrupt: %s>"), buf);
9235         }
9236       break;
9237
9238     case DT_MIPS_TIME_STAMP:
9239       {
9240         char timebuf[128];
9241         struct tm * tmp;
9242         time_t atime = entry->d_un.d_val;
9243
9244         tmp = gmtime (&atime);
9245         /* PR 17531: file: 6accc532.  */
9246         if (tmp == NULL)
9247           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9248         else
9249           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9250                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9251                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9252         printf (_("Time Stamp: %s"), timebuf);
9253       }
9254       break;
9255
9256     case DT_MIPS_RLD_VERSION:
9257     case DT_MIPS_LOCAL_GOTNO:
9258     case DT_MIPS_CONFLICTNO:
9259     case DT_MIPS_LIBLISTNO:
9260     case DT_MIPS_SYMTABNO:
9261     case DT_MIPS_UNREFEXTNO:
9262     case DT_MIPS_HIPAGENO:
9263     case DT_MIPS_DELTA_CLASS_NO:
9264     case DT_MIPS_DELTA_INSTANCE_NO:
9265     case DT_MIPS_DELTA_RELOC_NO:
9266     case DT_MIPS_DELTA_SYM_NO:
9267     case DT_MIPS_DELTA_CLASSSYM_NO:
9268     case DT_MIPS_COMPACT_SIZE:
9269       print_vma (entry->d_un.d_val, DEC);
9270       break;
9271
9272     default:
9273       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9274     }
9275     putchar ('\n');
9276 }
9277
9278 static void
9279 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9280 {
9281   switch (entry->d_tag)
9282     {
9283     case DT_HP_DLD_FLAGS:
9284       {
9285         static struct
9286         {
9287           long int bit;
9288           const char * str;
9289         }
9290         flags[] =
9291         {
9292           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9293           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9294           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9295           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9296           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9297           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9298           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9299           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9300           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9301           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9302           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9303           { DT_HP_GST, "HP_GST" },
9304           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9305           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9306           { DT_HP_NODELETE, "HP_NODELETE" },
9307           { DT_HP_GROUP, "HP_GROUP" },
9308           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9309         };
9310         bfd_boolean first = TRUE;
9311         size_t cnt;
9312         bfd_vma val = entry->d_un.d_val;
9313
9314         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9315           if (val & flags[cnt].bit)
9316             {
9317               if (! first)
9318                 putchar (' ');
9319               fputs (flags[cnt].str, stdout);
9320               first = FALSE;
9321               val ^= flags[cnt].bit;
9322             }
9323
9324         if (val != 0 || first)
9325           {
9326             if (! first)
9327               putchar (' ');
9328             print_vma (val, HEX);
9329           }
9330       }
9331       break;
9332
9333     default:
9334       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9335       break;
9336     }
9337   putchar ('\n');
9338 }
9339
9340 #ifdef BFD64
9341
9342 /* VMS vs Unix time offset and factor.  */
9343
9344 #define VMS_EPOCH_OFFSET 35067168000000000LL
9345 #define VMS_GRANULARITY_FACTOR 10000000
9346
9347 /* Display a VMS time in a human readable format.  */
9348
9349 static void
9350 print_vms_time (bfd_int64_t vmstime)
9351 {
9352   struct tm *tm;
9353   time_t unxtime;
9354
9355   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9356   tm = gmtime (&unxtime);
9357   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9358           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9359           tm->tm_hour, tm->tm_min, tm->tm_sec);
9360 }
9361 #endif /* BFD64 */
9362
9363 static void
9364 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9365 {
9366   switch (entry->d_tag)
9367     {
9368     case DT_IA_64_PLT_RESERVE:
9369       /* First 3 slots reserved.  */
9370       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9371       printf (" -- ");
9372       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9373       break;
9374
9375     case DT_IA_64_VMS_LINKTIME:
9376 #ifdef BFD64
9377       print_vms_time (entry->d_un.d_val);
9378 #endif
9379       break;
9380
9381     case DT_IA_64_VMS_LNKFLAGS:
9382       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9383       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9384         printf (" CALL_DEBUG");
9385       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9386         printf (" NOP0BUFS");
9387       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9388         printf (" P0IMAGE");
9389       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9390         printf (" MKTHREADS");
9391       if (entry->d_un.d_val & VMS_LF_UPCALLS)
9392         printf (" UPCALLS");
9393       if (entry->d_un.d_val & VMS_LF_IMGSTA)
9394         printf (" IMGSTA");
9395       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9396         printf (" INITIALIZE");
9397       if (entry->d_un.d_val & VMS_LF_MAIN)
9398         printf (" MAIN");
9399       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9400         printf (" EXE_INIT");
9401       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9402         printf (" TBK_IN_IMG");
9403       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9404         printf (" DBG_IN_IMG");
9405       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9406         printf (" TBK_IN_DSF");
9407       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9408         printf (" DBG_IN_DSF");
9409       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9410         printf (" SIGNATURES");
9411       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9412         printf (" REL_SEG_OFF");
9413       break;
9414
9415     default:
9416       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9417       break;
9418     }
9419   putchar ('\n');
9420 }
9421
9422 static bfd_boolean
9423 get_32bit_dynamic_section (Filedata * filedata)
9424 {
9425   Elf32_External_Dyn * edyn;
9426   Elf32_External_Dyn * ext;
9427   Elf_Internal_Dyn * entry;
9428
9429   edyn = (Elf32_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9430                                           dynamic_size, _("dynamic section"));
9431   if (!edyn)
9432     return FALSE;
9433
9434   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9435      might not have the luxury of section headers.  Look for the DT_NULL
9436      terminator to determine the number of entries.  */
9437   for (ext = edyn, dynamic_nent = 0;
9438        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9439        ext++)
9440     {
9441       dynamic_nent++;
9442       if (BYTE_GET (ext->d_tag) == DT_NULL)
9443         break;
9444     }
9445
9446   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9447                                                   sizeof (* entry));
9448   if (dynamic_section == NULL)
9449     {
9450       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9451              (unsigned long) dynamic_nent);
9452       free (edyn);
9453       return FALSE;
9454     }
9455
9456   for (ext = edyn, entry = dynamic_section;
9457        entry < dynamic_section + dynamic_nent;
9458        ext++, entry++)
9459     {
9460       entry->d_tag      = BYTE_GET (ext->d_tag);
9461       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9462     }
9463
9464   free (edyn);
9465
9466   return TRUE;
9467 }
9468
9469 static bfd_boolean
9470 get_64bit_dynamic_section (Filedata * filedata)
9471 {
9472   Elf64_External_Dyn * edyn;
9473   Elf64_External_Dyn * ext;
9474   Elf_Internal_Dyn * entry;
9475
9476   /* Read in the data.  */
9477   edyn = (Elf64_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9478                                           dynamic_size, _("dynamic section"));
9479   if (!edyn)
9480     return FALSE;
9481
9482   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9483      might not have the luxury of section headers.  Look for the DT_NULL
9484      terminator to determine the number of entries.  */
9485   for (ext = edyn, dynamic_nent = 0;
9486        /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer.  */
9487        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9488        ext++)
9489     {
9490       dynamic_nent++;
9491       if (BYTE_GET (ext->d_tag) == DT_NULL)
9492         break;
9493     }
9494
9495   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9496                                                   sizeof (* entry));
9497   if (dynamic_section == NULL)
9498     {
9499       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9500              (unsigned long) dynamic_nent);
9501       free (edyn);
9502       return FALSE;
9503     }
9504
9505   /* Convert from external to internal formats.  */
9506   for (ext = edyn, entry = dynamic_section;
9507        entry < dynamic_section + dynamic_nent;
9508        ext++, entry++)
9509     {
9510       entry->d_tag      = BYTE_GET (ext->d_tag);
9511       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9512     }
9513
9514   free (edyn);
9515
9516   return TRUE;
9517 }
9518
9519 static void
9520 print_dynamic_flags (bfd_vma flags)
9521 {
9522   bfd_boolean first = TRUE;
9523
9524   while (flags)
9525     {
9526       bfd_vma flag;
9527
9528       flag = flags & - flags;
9529       flags &= ~ flag;
9530
9531       if (first)
9532         first = FALSE;
9533       else
9534         putc (' ', stdout);
9535
9536       switch (flag)
9537         {
9538         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
9539         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
9540         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
9541         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
9542         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
9543         default:                fputs (_("unknown"), stdout); break;
9544         }
9545     }
9546   puts ("");
9547 }
9548
9549 /* Parse and display the contents of the dynamic section.  */
9550
9551 static bfd_boolean
9552 process_dynamic_section (Filedata * filedata)
9553 {
9554   Elf_Internal_Dyn * entry;
9555
9556   if (dynamic_size == 0)
9557     {
9558       if (do_dynamic)
9559         printf (_("\nThere is no dynamic section in this file.\n"));
9560
9561       return TRUE;
9562     }
9563
9564   if (is_32bit_elf)
9565     {
9566       if (! get_32bit_dynamic_section (filedata))
9567         return FALSE;
9568     }
9569   else
9570     {
9571       if (! get_64bit_dynamic_section (filedata))
9572         return FALSE;
9573     }
9574
9575   /* Find the appropriate symbol table.  */
9576   if (dynamic_symbols == NULL)
9577     {
9578       for (entry = dynamic_section;
9579            entry < dynamic_section + dynamic_nent;
9580            ++entry)
9581         {
9582           Elf_Internal_Shdr section;
9583
9584           if (entry->d_tag != DT_SYMTAB)
9585             continue;
9586
9587           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9588
9589           /* Since we do not know how big the symbol table is,
9590              we default to reading in the entire file (!) and
9591              processing that.  This is overkill, I know, but it
9592              should work.  */
9593           section.sh_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9594           if ((bfd_size_type) section.sh_offset > filedata->file_size)
9595             {
9596               /* See PR 21379 for a reproducer.  */
9597               error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9598               return FALSE;
9599             }
9600
9601           if (archive_file_offset != 0)
9602             section.sh_size = archive_file_size - section.sh_offset;
9603           else
9604             section.sh_size = filedata->file_size - section.sh_offset;
9605
9606           if (is_32bit_elf)
9607             section.sh_entsize = sizeof (Elf32_External_Sym);
9608           else
9609             section.sh_entsize = sizeof (Elf64_External_Sym);
9610           section.sh_name = filedata->string_table_length;
9611
9612           dynamic_symbols = GET_ELF_SYMBOLS (filedata, &section, & num_dynamic_syms);
9613           if (num_dynamic_syms < 1)
9614             {
9615               error (_("Unable to determine the number of symbols to load\n"));
9616               continue;
9617             }
9618         }
9619     }
9620
9621   /* Similarly find a string table.  */
9622   if (dynamic_strings == NULL)
9623     {
9624       for (entry = dynamic_section;
9625            entry < dynamic_section + dynamic_nent;
9626            ++entry)
9627         {
9628           unsigned long offset;
9629           long str_tab_len;
9630
9631           if (entry->d_tag != DT_STRTAB)
9632             continue;
9633
9634           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9635
9636           /* Since we do not know how big the string table is,
9637              we default to reading in the entire file (!) and
9638              processing that.  This is overkill, I know, but it
9639              should work.  */
9640
9641           offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9642
9643           if (archive_file_offset != 0)
9644             str_tab_len = archive_file_size - offset;
9645           else
9646             str_tab_len = filedata->file_size;
9647
9648           if (str_tab_len < 1)
9649             {
9650               error
9651                 (_("Unable to determine the length of the dynamic string table\n"));
9652               continue;
9653             }
9654
9655           dynamic_strings = (char *) get_data (NULL, filedata, offset, 1,
9656                                                str_tab_len,
9657                                                _("dynamic string table"));
9658           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9659           break;
9660         }
9661     }
9662
9663   /* And find the syminfo section if available.  */
9664   if (dynamic_syminfo == NULL)
9665     {
9666       unsigned long syminsz = 0;
9667
9668       for (entry = dynamic_section;
9669            entry < dynamic_section + dynamic_nent;
9670            ++entry)
9671         {
9672           if (entry->d_tag == DT_SYMINENT)
9673             {
9674               /* Note: these braces are necessary to avoid a syntax
9675                  error from the SunOS4 C compiler.  */
9676               /* PR binutils/17531: A corrupt file can trigger this test.
9677                  So do not use an assert, instead generate an error message.  */
9678               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9679                 error (_("Bad value (%d) for SYMINENT entry\n"),
9680                        (int) entry->d_un.d_val);
9681             }
9682           else if (entry->d_tag == DT_SYMINSZ)
9683             syminsz = entry->d_un.d_val;
9684           else if (entry->d_tag == DT_SYMINFO)
9685             dynamic_syminfo_offset = offset_from_vma (filedata, entry->d_un.d_val,
9686                                                       syminsz);
9687         }
9688
9689       if (dynamic_syminfo_offset != 0 && syminsz != 0)
9690         {
9691           Elf_External_Syminfo * extsyminfo;
9692           Elf_External_Syminfo * extsym;
9693           Elf_Internal_Syminfo * syminfo;
9694
9695           /* There is a syminfo section.  Read the data.  */
9696           extsyminfo = (Elf_External_Syminfo *)
9697               get_data (NULL, filedata, dynamic_syminfo_offset, 1, syminsz,
9698                         _("symbol information"));
9699           if (!extsyminfo)
9700             return FALSE;
9701
9702           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9703           if (dynamic_syminfo == NULL)
9704             {
9705               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9706                      (unsigned long) syminsz);
9707               return FALSE;
9708             }
9709
9710           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9711           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9712                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9713                ++syminfo, ++extsym)
9714             {
9715               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9716               syminfo->si_flags = BYTE_GET (extsym->si_flags);
9717             }
9718
9719           free (extsyminfo);
9720         }
9721     }
9722
9723   if (do_dynamic && dynamic_addr)
9724     printf (ngettext ("\nDynamic section at offset 0x%lx "
9725                       "contains %lu entry:\n",
9726                       "\nDynamic section at offset 0x%lx "
9727                       "contains %lu entries:\n",
9728                       dynamic_nent),
9729             dynamic_addr, (unsigned long) dynamic_nent);
9730   if (do_dynamic)
9731     printf (_("  Tag        Type                         Name/Value\n"));
9732
9733   for (entry = dynamic_section;
9734        entry < dynamic_section + dynamic_nent;
9735        entry++)
9736     {
9737       if (do_dynamic)
9738         {
9739           const char * dtype;
9740
9741           putchar (' ');
9742           print_vma (entry->d_tag, FULL_HEX);
9743           dtype = get_dynamic_type (filedata, entry->d_tag);
9744           printf (" (%s)%*s", dtype,
9745                   ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9746         }
9747
9748       switch (entry->d_tag)
9749         {
9750         case DT_FLAGS:
9751           if (do_dynamic)
9752             print_dynamic_flags (entry->d_un.d_val);
9753           break;
9754
9755         case DT_AUXILIARY:
9756         case DT_FILTER:
9757         case DT_CONFIG:
9758         case DT_DEPAUDIT:
9759         case DT_AUDIT:
9760           if (do_dynamic)
9761             {
9762               switch (entry->d_tag)
9763                 {
9764                 case DT_AUXILIARY:
9765                   printf (_("Auxiliary library"));
9766                   break;
9767
9768                 case DT_FILTER:
9769                   printf (_("Filter library"));
9770                   break;
9771
9772                 case DT_CONFIG:
9773                   printf (_("Configuration file"));
9774                   break;
9775
9776                 case DT_DEPAUDIT:
9777                   printf (_("Dependency audit library"));
9778                   break;
9779
9780                 case DT_AUDIT:
9781                   printf (_("Audit library"));
9782                   break;
9783                 }
9784
9785               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9786                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9787               else
9788                 {
9789                   printf (": ");
9790                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9791                   putchar ('\n');
9792                 }
9793             }
9794           break;
9795
9796         case DT_FEATURE:
9797           if (do_dynamic)
9798             {
9799               printf (_("Flags:"));
9800
9801               if (entry->d_un.d_val == 0)
9802                 printf (_(" None\n"));
9803               else
9804                 {
9805                   unsigned long int val = entry->d_un.d_val;
9806
9807                   if (val & DTF_1_PARINIT)
9808                     {
9809                       printf (" PARINIT");
9810                       val ^= DTF_1_PARINIT;
9811                     }
9812                   if (val & DTF_1_CONFEXP)
9813                     {
9814                       printf (" CONFEXP");
9815                       val ^= DTF_1_CONFEXP;
9816                     }
9817                   if (val != 0)
9818                     printf (" %lx", val);
9819                   puts ("");
9820                 }
9821             }
9822           break;
9823
9824         case DT_POSFLAG_1:
9825           if (do_dynamic)
9826             {
9827               printf (_("Flags:"));
9828
9829               if (entry->d_un.d_val == 0)
9830                 printf (_(" None\n"));
9831               else
9832                 {
9833                   unsigned long int val = entry->d_un.d_val;
9834
9835                   if (val & DF_P1_LAZYLOAD)
9836                     {
9837                       printf (" LAZYLOAD");
9838                       val ^= DF_P1_LAZYLOAD;
9839                     }
9840                   if (val & DF_P1_GROUPPERM)
9841                     {
9842                       printf (" GROUPPERM");
9843                       val ^= DF_P1_GROUPPERM;
9844                     }
9845                   if (val != 0)
9846                     printf (" %lx", val);
9847                   puts ("");
9848                 }
9849             }
9850           break;
9851
9852         case DT_FLAGS_1:
9853           if (do_dynamic)
9854             {
9855               printf (_("Flags:"));
9856               if (entry->d_un.d_val == 0)
9857                 printf (_(" None\n"));
9858               else
9859                 {
9860                   unsigned long int val = entry->d_un.d_val;
9861
9862                   if (val & DF_1_NOW)
9863                     {
9864                       printf (" NOW");
9865                       val ^= DF_1_NOW;
9866                     }
9867                   if (val & DF_1_GLOBAL)
9868                     {
9869                       printf (" GLOBAL");
9870                       val ^= DF_1_GLOBAL;
9871                     }
9872                   if (val & DF_1_GROUP)
9873                     {
9874                       printf (" GROUP");
9875                       val ^= DF_1_GROUP;
9876                     }
9877                   if (val & DF_1_NODELETE)
9878                     {
9879                       printf (" NODELETE");
9880                       val ^= DF_1_NODELETE;
9881                     }
9882                   if (val & DF_1_LOADFLTR)
9883                     {
9884                       printf (" LOADFLTR");
9885                       val ^= DF_1_LOADFLTR;
9886                     }
9887                   if (val & DF_1_INITFIRST)
9888                     {
9889                       printf (" INITFIRST");
9890                       val ^= DF_1_INITFIRST;
9891                     }
9892                   if (val & DF_1_NOOPEN)
9893                     {
9894                       printf (" NOOPEN");
9895                       val ^= DF_1_NOOPEN;
9896                     }
9897                   if (val & DF_1_ORIGIN)
9898                     {
9899                       printf (" ORIGIN");
9900                       val ^= DF_1_ORIGIN;
9901                     }
9902                   if (val & DF_1_DIRECT)
9903                     {
9904                       printf (" DIRECT");
9905                       val ^= DF_1_DIRECT;
9906                     }
9907                   if (val & DF_1_TRANS)
9908                     {
9909                       printf (" TRANS");
9910                       val ^= DF_1_TRANS;
9911                     }
9912                   if (val & DF_1_INTERPOSE)
9913                     {
9914                       printf (" INTERPOSE");
9915                       val ^= DF_1_INTERPOSE;
9916                     }
9917                   if (val & DF_1_NODEFLIB)
9918                     {
9919                       printf (" NODEFLIB");
9920                       val ^= DF_1_NODEFLIB;
9921                     }
9922                   if (val & DF_1_NODUMP)
9923                     {
9924                       printf (" NODUMP");
9925                       val ^= DF_1_NODUMP;
9926                     }
9927                   if (val & DF_1_CONFALT)
9928                     {
9929                       printf (" CONFALT");
9930                       val ^= DF_1_CONFALT;
9931                     }
9932                   if (val & DF_1_ENDFILTEE)
9933                     {
9934                       printf (" ENDFILTEE");
9935                       val ^= DF_1_ENDFILTEE;
9936                     }
9937                   if (val & DF_1_DISPRELDNE)
9938                     {
9939                       printf (" DISPRELDNE");
9940                       val ^= DF_1_DISPRELDNE;
9941                     }
9942                   if (val & DF_1_DISPRELPND)
9943                     {
9944                       printf (" DISPRELPND");
9945                       val ^= DF_1_DISPRELPND;
9946                     }
9947                   if (val & DF_1_NODIRECT)
9948                     {
9949                       printf (" NODIRECT");
9950                       val ^= DF_1_NODIRECT;
9951                     }
9952                   if (val & DF_1_IGNMULDEF)
9953                     {
9954                       printf (" IGNMULDEF");
9955                       val ^= DF_1_IGNMULDEF;
9956                     }
9957                   if (val & DF_1_NOKSYMS)
9958                     {
9959                       printf (" NOKSYMS");
9960                       val ^= DF_1_NOKSYMS;
9961                     }
9962                   if (val & DF_1_NOHDR)
9963                     {
9964                       printf (" NOHDR");
9965                       val ^= DF_1_NOHDR;
9966                     }
9967                   if (val & DF_1_EDITED)
9968                     {
9969                       printf (" EDITED");
9970                       val ^= DF_1_EDITED;
9971                     }
9972                   if (val & DF_1_NORELOC)
9973                     {
9974                       printf (" NORELOC");
9975                       val ^= DF_1_NORELOC;
9976                     }
9977                   if (val & DF_1_SYMINTPOSE)
9978                     {
9979                       printf (" SYMINTPOSE");
9980                       val ^= DF_1_SYMINTPOSE;
9981                     }
9982                   if (val & DF_1_GLOBAUDIT)
9983                     {
9984                       printf (" GLOBAUDIT");
9985                       val ^= DF_1_GLOBAUDIT;
9986                     }
9987                   if (val & DF_1_SINGLETON)
9988                     {
9989                       printf (" SINGLETON");
9990                       val ^= DF_1_SINGLETON;
9991                     }
9992                   if (val & DF_1_STUB)
9993                     {
9994                       printf (" STUB");
9995                       val ^= DF_1_STUB;
9996                     }
9997                   if (val & DF_1_PIE)
9998                     {
9999                       printf (" PIE");
10000                       val ^= DF_1_PIE;
10001                     }
10002                   if (val != 0)
10003                     printf (" %lx", val);
10004                   puts ("");
10005                 }
10006             }
10007           break;
10008
10009         case DT_PLTREL:
10010           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10011           if (do_dynamic)
10012             puts (get_dynamic_type (filedata, entry->d_un.d_val));
10013           break;
10014
10015         case DT_NULL    :
10016         case DT_NEEDED  :
10017         case DT_PLTGOT  :
10018         case DT_HASH    :
10019         case DT_STRTAB  :
10020         case DT_SYMTAB  :
10021         case DT_RELA    :
10022         case DT_INIT    :
10023         case DT_FINI    :
10024         case DT_SONAME  :
10025         case DT_RPATH   :
10026         case DT_SYMBOLIC:
10027         case DT_REL     :
10028         case DT_DEBUG   :
10029         case DT_TEXTREL :
10030         case DT_JMPREL  :
10031         case DT_RUNPATH :
10032           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10033
10034           if (do_dynamic)
10035             {
10036               char * name;
10037
10038               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10039                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10040               else
10041                 name = NULL;
10042
10043               if (name)
10044                 {
10045                   switch (entry->d_tag)
10046                     {
10047                     case DT_NEEDED:
10048                       printf (_("Shared library: [%s]"), name);
10049
10050                       if (streq (name, program_interpreter))
10051                         printf (_(" program interpreter"));
10052                       break;
10053
10054                     case DT_SONAME:
10055                       printf (_("Library soname: [%s]"), name);
10056                       break;
10057
10058                     case DT_RPATH:
10059                       printf (_("Library rpath: [%s]"), name);
10060                       break;
10061
10062                     case DT_RUNPATH:
10063                       printf (_("Library runpath: [%s]"), name);
10064                       break;
10065
10066                     default:
10067                       print_vma (entry->d_un.d_val, PREFIX_HEX);
10068                       break;
10069                     }
10070                 }
10071               else
10072                 print_vma (entry->d_un.d_val, PREFIX_HEX);
10073
10074               putchar ('\n');
10075             }
10076           break;
10077
10078         case DT_PLTRELSZ:
10079         case DT_RELASZ  :
10080         case DT_STRSZ   :
10081         case DT_RELSZ   :
10082         case DT_RELAENT :
10083         case DT_SYMENT  :
10084         case DT_RELENT  :
10085           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10086           /* Fall through.  */
10087         case DT_PLTPADSZ:
10088         case DT_MOVEENT :
10089         case DT_MOVESZ  :
10090         case DT_INIT_ARRAYSZ:
10091         case DT_FINI_ARRAYSZ:
10092         case DT_GNU_CONFLICTSZ:
10093         case DT_GNU_LIBLISTSZ:
10094           if (do_dynamic)
10095             {
10096               print_vma (entry->d_un.d_val, UNSIGNED);
10097               printf (_(" (bytes)\n"));
10098             }
10099           break;
10100
10101         case DT_VERDEFNUM:
10102         case DT_VERNEEDNUM:
10103         case DT_RELACOUNT:
10104         case DT_RELCOUNT:
10105           if (do_dynamic)
10106             {
10107               print_vma (entry->d_un.d_val, UNSIGNED);
10108               putchar ('\n');
10109             }
10110           break;
10111
10112         case DT_SYMINSZ:
10113         case DT_SYMINENT:
10114         case DT_SYMINFO:
10115         case DT_USED:
10116         case DT_INIT_ARRAY:
10117         case DT_FINI_ARRAY:
10118           if (do_dynamic)
10119             {
10120               if (entry->d_tag == DT_USED
10121                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10122                 {
10123                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10124
10125                   if (*name)
10126                     {
10127                       printf (_("Not needed object: [%s]\n"), name);
10128                       break;
10129                     }
10130                 }
10131
10132               print_vma (entry->d_un.d_val, PREFIX_HEX);
10133               putchar ('\n');
10134             }
10135           break;
10136
10137         case DT_BIND_NOW:
10138           /* The value of this entry is ignored.  */
10139           if (do_dynamic)
10140             putchar ('\n');
10141           break;
10142
10143         case DT_GNU_PRELINKED:
10144           if (do_dynamic)
10145             {
10146               struct tm * tmp;
10147               time_t atime = entry->d_un.d_val;
10148
10149               tmp = gmtime (&atime);
10150               /* PR 17533 file: 041-1244816-0.004.  */
10151               if (tmp == NULL)
10152                 printf (_("<corrupt time val: %lx"),
10153                         (unsigned long) atime);
10154               else
10155                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10156                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10157                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10158
10159             }
10160           break;
10161
10162         case DT_GNU_HASH:
10163           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10164           if (do_dynamic)
10165             {
10166               print_vma (entry->d_un.d_val, PREFIX_HEX);
10167               putchar ('\n');
10168             }
10169           break;
10170
10171         default:
10172           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10173             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10174               entry->d_un.d_val;
10175
10176           if (do_dynamic)
10177             {
10178               switch (filedata->file_header.e_machine)
10179                 {
10180                 case EM_MIPS:
10181                 case EM_MIPS_RS3_LE:
10182                   dynamic_section_mips_val (entry);
10183                   break;
10184                 case EM_PARISC:
10185                   dynamic_section_parisc_val (entry);
10186                   break;
10187                 case EM_IA_64:
10188                   dynamic_section_ia64_val (entry);
10189                   break;
10190                 default:
10191                   print_vma (entry->d_un.d_val, PREFIX_HEX);
10192                   putchar ('\n');
10193                 }
10194             }
10195           break;
10196         }
10197     }
10198
10199   return TRUE;
10200 }
10201
10202 static char *
10203 get_ver_flags (unsigned int flags)
10204 {
10205   static char buff[32];
10206
10207   buff[0] = 0;
10208
10209   if (flags == 0)
10210     return _("none");
10211
10212   if (flags & VER_FLG_BASE)
10213     strcat (buff, "BASE");
10214
10215   if (flags & VER_FLG_WEAK)
10216     {
10217       if (flags & VER_FLG_BASE)
10218         strcat (buff, " | ");
10219
10220       strcat (buff, "WEAK");
10221     }
10222
10223   if (flags & VER_FLG_INFO)
10224     {
10225       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10226         strcat (buff, " | ");
10227
10228       strcat (buff, "INFO");
10229     }
10230
10231   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10232     {
10233       if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10234         strcat (buff, " | ");
10235
10236       strcat (buff, _("<unknown>"));
10237     }
10238
10239   return buff;
10240 }
10241
10242 /* Display the contents of the version sections.  */
10243
10244 static bfd_boolean
10245 process_version_sections (Filedata * filedata)
10246 {
10247   Elf_Internal_Shdr * section;
10248   unsigned i;
10249   bfd_boolean found = FALSE;
10250
10251   if (! do_version)
10252     return TRUE;
10253
10254   for (i = 0, section = filedata->section_headers;
10255        i < filedata->file_header.e_shnum;
10256        i++, section++)
10257     {
10258       switch (section->sh_type)
10259         {
10260         case SHT_GNU_verdef:
10261           {
10262             Elf_External_Verdef * edefs;
10263             unsigned long idx;
10264             unsigned long cnt;
10265             char * endbuf;
10266
10267             found = TRUE;
10268
10269             printf (ngettext ("\nVersion definition section '%s' "
10270                               "contains %u entry:\n",
10271                               "\nVersion definition section '%s' "
10272                               "contains %u entries:\n",
10273                               section->sh_info),
10274                     printable_section_name (filedata, section),
10275                     section->sh_info);
10276
10277             printf (_("  Addr: 0x"));
10278             printf_vma (section->sh_addr);
10279             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10280                     (unsigned long) section->sh_offset, section->sh_link,
10281                     printable_section_name_from_index (filedata, section->sh_link));
10282
10283             edefs = (Elf_External_Verdef *)
10284                 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
10285                           _("version definition section"));
10286             if (!edefs)
10287               break;
10288             endbuf = (char *) edefs + section->sh_size;
10289
10290             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10291               {
10292                 char * vstart;
10293                 Elf_External_Verdef * edef;
10294                 Elf_Internal_Verdef ent;
10295                 Elf_External_Verdaux * eaux;
10296                 Elf_Internal_Verdaux aux;
10297                 unsigned long isum;
10298                 int j;
10299
10300                 vstart = ((char *) edefs) + idx;
10301                 if (vstart + sizeof (*edef) > endbuf)
10302                   break;
10303
10304                 edef = (Elf_External_Verdef *) vstart;
10305
10306                 ent.vd_version = BYTE_GET (edef->vd_version);
10307                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
10308                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
10309                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
10310                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
10311                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
10312                 ent.vd_next    = BYTE_GET (edef->vd_next);
10313
10314                 printf (_("  %#06lx: Rev: %d  Flags: %s"),
10315                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10316
10317                 printf (_("  Index: %d  Cnt: %d  "),
10318                         ent.vd_ndx, ent.vd_cnt);
10319
10320                 /* Check for overflow.  */
10321                 if (ent.vd_aux > (size_t) (endbuf - vstart))
10322                   break;
10323
10324                 vstart += ent.vd_aux;
10325
10326                 if (vstart + sizeof (*eaux) > endbuf)
10327                   break;
10328                 eaux = (Elf_External_Verdaux *) vstart;
10329
10330                 aux.vda_name = BYTE_GET (eaux->vda_name);
10331                 aux.vda_next = BYTE_GET (eaux->vda_next);
10332
10333                 if (VALID_DYNAMIC_NAME (aux.vda_name))
10334                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10335                 else
10336                   printf (_("Name index: %ld\n"), aux.vda_name);
10337
10338                 isum = idx + ent.vd_aux;
10339
10340                 for (j = 1; j < ent.vd_cnt; j++)
10341                   {
10342                     if (aux.vda_next < sizeof (*eaux)
10343                         && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10344                       {
10345                         warn (_("Invalid vda_next field of %lx\n"),
10346                               aux.vda_next);
10347                         j = ent.vd_cnt;
10348                         break;
10349                       }
10350                     /* Check for overflow.  */
10351                     if (aux.vda_next > (size_t) (endbuf - vstart))
10352                       break;
10353
10354                     isum   += aux.vda_next;
10355                     vstart += aux.vda_next;
10356
10357                     if (vstart + sizeof (*eaux) > endbuf)
10358                       break;
10359                     eaux = (Elf_External_Verdaux *) vstart;
10360
10361                     aux.vda_name = BYTE_GET (eaux->vda_name);
10362                     aux.vda_next = BYTE_GET (eaux->vda_next);
10363
10364                     if (VALID_DYNAMIC_NAME (aux.vda_name))
10365                       printf (_("  %#06lx: Parent %d: %s\n"),
10366                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10367                     else
10368                       printf (_("  %#06lx: Parent %d, name index: %ld\n"),
10369                               isum, j, aux.vda_name);
10370                   }
10371
10372                 if (j < ent.vd_cnt)
10373                   printf (_("  Version def aux past end of section\n"));
10374
10375                 /* PR 17531:
10376                    file: id:000001,src:000172+005151,op:splice,rep:2.  */
10377                 if (ent.vd_next < sizeof (*edef)
10378                     && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10379                   {
10380                     warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10381                     cnt = section->sh_info;
10382                     break;
10383                   }
10384                 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10385                   break;
10386
10387                 idx += ent.vd_next;
10388               }
10389
10390             if (cnt < section->sh_info)
10391               printf (_("  Version definition past end of section\n"));
10392
10393             free (edefs);
10394           }
10395           break;
10396
10397         case SHT_GNU_verneed:
10398           {
10399             Elf_External_Verneed * eneed;
10400             unsigned long idx;
10401             unsigned long cnt;
10402             char * endbuf;
10403
10404             found = TRUE;
10405
10406             printf (ngettext ("\nVersion needs section '%s' "
10407                               "contains %u entry:\n",
10408                               "\nVersion needs section '%s' "
10409                               "contains %u entries:\n",
10410                               section->sh_info),
10411                     printable_section_name (filedata, section), section->sh_info);
10412
10413             printf (_(" Addr: 0x"));
10414             printf_vma (section->sh_addr);
10415             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10416                     (unsigned long) section->sh_offset, section->sh_link,
10417                     printable_section_name_from_index (filedata, section->sh_link));
10418
10419             eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
10420                                                        section->sh_offset, 1,
10421                                                        section->sh_size,
10422                                                        _("Version Needs section"));
10423             if (!eneed)
10424               break;
10425             endbuf = (char *) eneed + section->sh_size;
10426
10427             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10428               {
10429                 Elf_External_Verneed * entry;
10430                 Elf_Internal_Verneed ent;
10431                 unsigned long isum;
10432                 int j;
10433                 char * vstart;
10434
10435                 vstart = ((char *) eneed) + idx;
10436                 if (vstart + sizeof (*entry) > endbuf)
10437                   break;
10438
10439                 entry = (Elf_External_Verneed *) vstart;
10440
10441                 ent.vn_version = BYTE_GET (entry->vn_version);
10442                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
10443                 ent.vn_file    = BYTE_GET (entry->vn_file);
10444                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
10445                 ent.vn_next    = BYTE_GET (entry->vn_next);
10446
10447                 printf (_("  %#06lx: Version: %d"), idx, ent.vn_version);
10448
10449                 if (VALID_DYNAMIC_NAME (ent.vn_file))
10450                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10451                 else
10452                   printf (_("  File: %lx"), ent.vn_file);
10453
10454                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
10455
10456                 /* Check for overflow.  */
10457                 if (ent.vn_aux > (size_t) (endbuf - vstart))
10458                   break;
10459                 vstart += ent.vn_aux;
10460
10461                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10462                   {
10463                     Elf_External_Vernaux * eaux;
10464                     Elf_Internal_Vernaux aux;
10465
10466                     if (vstart + sizeof (*eaux) > endbuf)
10467                       break;
10468                     eaux = (Elf_External_Vernaux *) vstart;
10469
10470                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
10471                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
10472                     aux.vna_other = BYTE_GET (eaux->vna_other);
10473                     aux.vna_name  = BYTE_GET (eaux->vna_name);
10474                     aux.vna_next  = BYTE_GET (eaux->vna_next);
10475
10476                     if (VALID_DYNAMIC_NAME (aux.vna_name))
10477                       printf (_("  %#06lx:   Name: %s"),
10478                               isum, GET_DYNAMIC_NAME (aux.vna_name));
10479                     else
10480                       printf (_("  %#06lx:   Name index: %lx"),
10481                               isum, aux.vna_name);
10482
10483                     printf (_("  Flags: %s  Version: %d\n"),
10484                             get_ver_flags (aux.vna_flags), aux.vna_other);
10485
10486                     if (aux.vna_next < sizeof (*eaux)
10487                         && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10488                       {
10489                         warn (_("Invalid vna_next field of %lx\n"),
10490                               aux.vna_next);
10491                         j = ent.vn_cnt;
10492                         break;
10493                       }
10494                     /* Check for overflow.  */
10495                     if (aux.vna_next > (size_t) (endbuf - vstart))
10496                       break;
10497                     isum   += aux.vna_next;
10498                     vstart += aux.vna_next;
10499                   }
10500
10501                 if (j < ent.vn_cnt)
10502                   warn (_("Missing Version Needs auxillary information\n"));
10503
10504                 if (ent.vn_next < sizeof (*entry)
10505                     && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10506                   {
10507                     warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10508                     cnt = section->sh_info;
10509                     break;
10510                   }
10511                 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10512                   break;
10513                 idx += ent.vn_next;
10514               }
10515
10516             if (cnt < section->sh_info)
10517               warn (_("Missing Version Needs information\n"));
10518
10519             free (eneed);
10520           }
10521           break;
10522
10523         case SHT_GNU_versym:
10524           {
10525             Elf_Internal_Shdr * link_section;
10526             size_t total;
10527             unsigned int cnt;
10528             unsigned char * edata;
10529             unsigned short * data;
10530             char * strtab;
10531             Elf_Internal_Sym * symbols;
10532             Elf_Internal_Shdr * string_sec;
10533             unsigned long num_syms;
10534             long off;
10535
10536             if (section->sh_link >= filedata->file_header.e_shnum)
10537               break;
10538
10539             link_section = filedata->section_headers + section->sh_link;
10540             total = section->sh_size / sizeof (Elf_External_Versym);
10541
10542             if (link_section->sh_link >= filedata->file_header.e_shnum)
10543               break;
10544
10545             found = TRUE;
10546
10547             symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
10548             if (symbols == NULL)
10549               break;
10550
10551             string_sec = filedata->section_headers + link_section->sh_link;
10552
10553             strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
10554                                         string_sec->sh_size,
10555                                         _("version string table"));
10556             if (!strtab)
10557               {
10558                 free (symbols);
10559                 break;
10560               }
10561
10562             printf (ngettext ("\nVersion symbols section '%s' "
10563                               "contains %lu entry:\n",
10564                               "\nVersion symbols section '%s' "
10565                               "contains %lu entries:\n",
10566                               total),
10567                     printable_section_name (filedata, section), (unsigned long) total);
10568
10569             printf (_(" Addr: "));
10570             printf_vma (section->sh_addr);
10571             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10572                     (unsigned long) section->sh_offset, section->sh_link,
10573                     printable_section_name (filedata, link_section));
10574
10575             off = offset_from_vma (filedata,
10576                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10577                                    total * sizeof (short));
10578             edata = (unsigned char *) get_data (NULL, filedata, off, total,
10579                                                 sizeof (short),
10580                                                 _("version symbol data"));
10581             if (!edata)
10582               {
10583                 free (strtab);
10584                 free (symbols);
10585                 break;
10586               }
10587
10588             data = (short unsigned int *) cmalloc (total, sizeof (short));
10589
10590             for (cnt = total; cnt --;)
10591               data[cnt] = byte_get (edata + cnt * sizeof (short),
10592                                     sizeof (short));
10593
10594             free (edata);
10595
10596             for (cnt = 0; cnt < total; cnt += 4)
10597               {
10598                 int j, nn;
10599                 char *name;
10600                 char *invalid = _("*invalid*");
10601
10602                 printf ("  %03x:", cnt);
10603
10604                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10605                   switch (data[cnt + j])
10606                     {
10607                     case 0:
10608                       fputs (_("   0 (*local*)    "), stdout);
10609                       break;
10610
10611                     case 1:
10612                       fputs (_("   1 (*global*)   "), stdout);
10613                       break;
10614
10615                     default:
10616                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10617                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10618
10619                       /* If this index value is greater than the size of the symbols
10620                          array, break to avoid an out-of-bounds read.  */
10621                       if ((unsigned long)(cnt + j) >= num_syms)
10622                         {
10623                           warn (_("invalid index into symbol array\n"));
10624                           break;
10625                         }
10626
10627                       name = NULL;
10628                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10629                         {
10630                           Elf_Internal_Verneed ivn;
10631                           unsigned long offset;
10632
10633                           offset = offset_from_vma
10634                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10635                              sizeof (Elf_External_Verneed));
10636
10637                           do
10638                             {
10639                               Elf_Internal_Vernaux ivna;
10640                               Elf_External_Verneed evn;
10641                               Elf_External_Vernaux evna;
10642                               unsigned long a_off;
10643
10644                               if (get_data (&evn, filedata, offset, sizeof (evn), 1,
10645                                             _("version need")) == NULL)
10646                                 break;
10647
10648                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10649                               ivn.vn_next = BYTE_GET (evn.vn_next);
10650
10651                               a_off = offset + ivn.vn_aux;
10652
10653                               do
10654                                 {
10655                                   if (get_data (&evna, filedata, a_off, sizeof (evna),
10656                                                 1, _("version need aux (2)")) == NULL)
10657                                     {
10658                                       ivna.vna_next  = 0;
10659                                       ivna.vna_other = 0;
10660                                     }
10661                                   else
10662                                     {
10663                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
10664                                       ivna.vna_other = BYTE_GET (evna.vna_other);
10665                                     }
10666
10667                                   a_off += ivna.vna_next;
10668                                 }
10669                               while (ivna.vna_other != data[cnt + j]
10670                                      && ivna.vna_next != 0);
10671
10672                               if (ivna.vna_other == data[cnt + j])
10673                                 {
10674                                   ivna.vna_name = BYTE_GET (evna.vna_name);
10675
10676                                   if (ivna.vna_name >= string_sec->sh_size)
10677                                     name = invalid;
10678                                   else
10679                                     name = strtab + ivna.vna_name;
10680                                   break;
10681                                 }
10682
10683                               offset += ivn.vn_next;
10684                             }
10685                           while (ivn.vn_next);
10686                         }
10687
10688                       if (data[cnt + j] != 0x8001
10689                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10690                         {
10691                           Elf_Internal_Verdef ivd;
10692                           Elf_External_Verdef evd;
10693                           unsigned long offset;
10694
10695                           offset = offset_from_vma
10696                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10697                              sizeof evd);
10698
10699                           do
10700                             {
10701                               if (get_data (&evd, filedata, offset, sizeof (evd), 1,
10702                                             _("version def")) == NULL)
10703                                 {
10704                                   ivd.vd_next = 0;
10705                                   /* PR 17531: file: 046-1082287-0.004.  */
10706                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
10707                                   break;
10708                                 }
10709                               else
10710                                 {
10711                                   ivd.vd_next = BYTE_GET (evd.vd_next);
10712                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
10713                                 }
10714
10715                               offset += ivd.vd_next;
10716                             }
10717                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10718                                  && ivd.vd_next != 0);
10719
10720                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10721                             {
10722                               Elf_External_Verdaux evda;
10723                               Elf_Internal_Verdaux ivda;
10724
10725                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
10726
10727                               if (get_data (&evda, filedata,
10728                                             offset - ivd.vd_next + ivd.vd_aux,
10729                                             sizeof (evda), 1,
10730                                             _("version def aux")) == NULL)
10731                                 break;
10732
10733                               ivda.vda_name = BYTE_GET (evda.vda_name);
10734
10735                               if (ivda.vda_name >= string_sec->sh_size)
10736                                 name = invalid;
10737                               else if (name != NULL && name != invalid)
10738                                 name = _("*both*");
10739                               else
10740                                 name = strtab + ivda.vda_name;
10741                             }
10742                         }
10743                       if (name != NULL)
10744                         nn += printf ("(%s%-*s",
10745                                       name,
10746                                       12 - (int) strlen (name),
10747                                       ")");
10748
10749                       if (nn < 18)
10750                         printf ("%*c", 18 - nn, ' ');
10751                     }
10752
10753                 putchar ('\n');
10754               }
10755
10756             free (data);
10757             free (strtab);
10758             free (symbols);
10759           }
10760           break;
10761
10762         default:
10763           break;
10764         }
10765     }
10766
10767   if (! found)
10768     printf (_("\nNo version information found in this file.\n"));
10769
10770   return TRUE;
10771 }
10772
10773 static const char *
10774 get_symbol_binding (Filedata * filedata, unsigned int binding)
10775 {
10776   static char buff[32];
10777
10778   switch (binding)
10779     {
10780     case STB_LOCAL:     return "LOCAL";
10781     case STB_GLOBAL:    return "GLOBAL";
10782     case STB_WEAK:      return "WEAK";
10783     default:
10784       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10785         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10786                   binding);
10787       else if (binding >= STB_LOOS && binding <= STB_HIOS)
10788         {
10789           if (binding == STB_GNU_UNIQUE
10790               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10791                   /* GNU is still using the default value 0.  */
10792                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10793             return "UNIQUE";
10794           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10795         }
10796       else
10797         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10798       return buff;
10799     }
10800 }
10801
10802 static const char *
10803 get_symbol_type (Filedata * filedata, unsigned int type)
10804 {
10805   static char buff[32];
10806
10807   switch (type)
10808     {
10809     case STT_NOTYPE:    return "NOTYPE";
10810     case STT_OBJECT:    return "OBJECT";
10811     case STT_FUNC:      return "FUNC";
10812     case STT_SECTION:   return "SECTION";
10813     case STT_FILE:      return "FILE";
10814     case STT_COMMON:    return "COMMON";
10815     case STT_TLS:       return "TLS";
10816     case STT_RELC:      return "RELC";
10817     case STT_SRELC:     return "SRELC";
10818     default:
10819       if (type >= STT_LOPROC && type <= STT_HIPROC)
10820         {
10821           if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10822             return "THUMB_FUNC";
10823
10824           if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10825             return "REGISTER";
10826
10827           if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10828             return "PARISC_MILLI";
10829
10830           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10831         }
10832       else if (type >= STT_LOOS && type <= STT_HIOS)
10833         {
10834           if (filedata->file_header.e_machine == EM_PARISC)
10835             {
10836               if (type == STT_HP_OPAQUE)
10837                 return "HP_OPAQUE";
10838               if (type == STT_HP_STUB)
10839                 return "HP_STUB";
10840             }
10841
10842           if (type == STT_GNU_IFUNC
10843               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10844                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10845                   /* GNU is still using the default value 0.  */
10846                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10847             return "IFUNC";
10848
10849           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10850         }
10851       else
10852         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10853       return buff;
10854     }
10855 }
10856
10857 static const char *
10858 get_symbol_visibility (unsigned int visibility)
10859 {
10860   switch (visibility)
10861     {
10862     case STV_DEFAULT:   return "DEFAULT";
10863     case STV_INTERNAL:  return "INTERNAL";
10864     case STV_HIDDEN:    return "HIDDEN";
10865     case STV_PROTECTED: return "PROTECTED";
10866     default:
10867       error (_("Unrecognized visibility value: %u"), visibility);
10868       return _("<unknown>");
10869     }
10870 }
10871
10872 static const char *
10873 get_solaris_symbol_visibility (unsigned int visibility)
10874 {
10875   switch (visibility)
10876     {
10877     case 4: return "EXPORTED";
10878     case 5: return "SINGLETON";
10879     case 6: return "ELIMINATE";
10880     default: return get_symbol_visibility (visibility);
10881     }
10882 }
10883
10884 static const char *
10885 get_mips_symbol_other (unsigned int other)
10886 {
10887   switch (other)
10888     {
10889     case STO_OPTIONAL:      return "OPTIONAL";
10890     case STO_MIPS_PLT:      return "MIPS PLT";
10891     case STO_MIPS_PIC:      return "MIPS PIC";
10892     case STO_MICROMIPS:     return "MICROMIPS";
10893     case STO_MICROMIPS | STO_MIPS_PIC:      return "MICROMIPS, MIPS PIC";
10894     case STO_MIPS16:        return "MIPS16";
10895     default:                return NULL;
10896     }
10897 }
10898
10899 static const char *
10900 get_ia64_symbol_other (Filedata * filedata, unsigned int other)
10901 {
10902   if (is_ia64_vms (filedata))
10903     {
10904       static char res[32];
10905
10906       res[0] = 0;
10907
10908       /* Function types is for images and .STB files only.  */
10909       switch (filedata->file_header.e_type)
10910         {
10911         case ET_DYN:
10912         case ET_EXEC:
10913           switch (VMS_ST_FUNC_TYPE (other))
10914             {
10915             case VMS_SFT_CODE_ADDR:
10916               strcat (res, " CA");
10917               break;
10918             case VMS_SFT_SYMV_IDX:
10919               strcat (res, " VEC");
10920               break;
10921             case VMS_SFT_FD:
10922               strcat (res, " FD");
10923               break;
10924             case VMS_SFT_RESERVE:
10925               strcat (res, " RSV");
10926               break;
10927             default:
10928               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10929                     VMS_ST_FUNC_TYPE (other));
10930               strcat (res, " <unknown>");
10931               break;
10932             }
10933           break;
10934         default:
10935           break;
10936         }
10937       switch (VMS_ST_LINKAGE (other))
10938         {
10939         case VMS_STL_IGNORE:
10940           strcat (res, " IGN");
10941           break;
10942         case VMS_STL_RESERVE:
10943           strcat (res, " RSV");
10944           break;
10945         case VMS_STL_STD:
10946           strcat (res, " STD");
10947           break;
10948         case VMS_STL_LNK:
10949           strcat (res, " LNK");
10950           break;
10951         default:
10952           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10953                 VMS_ST_LINKAGE (other));
10954           strcat (res, " <unknown>");
10955           break;
10956         }
10957
10958       if (res[0] != 0)
10959         return res + 1;
10960       else
10961         return res;
10962     }
10963   return NULL;
10964 }
10965
10966 static const char *
10967 get_ppc64_symbol_other (unsigned int other)
10968 {
10969   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10970     {
10971       static char buf[32];
10972       snprintf (buf, sizeof buf, _("<localentry>: %d"),
10973                 PPC64_LOCAL_ENTRY_OFFSET (other));
10974       return buf;
10975     }
10976   return NULL;
10977 }
10978
10979 static const char *
10980 get_symbol_other (Filedata * filedata, unsigned int other)
10981 {
10982   const char * result = NULL;
10983   static char buff [32];
10984
10985   if (other == 0)
10986     return "";
10987
10988   switch (filedata->file_header.e_machine)
10989     {
10990     case EM_MIPS:
10991       result = get_mips_symbol_other (other);
10992       break;
10993     case EM_IA_64:
10994       result = get_ia64_symbol_other (filedata, other);
10995       break;
10996     case EM_PPC64:
10997       result = get_ppc64_symbol_other (other);
10998       break;
10999     default:
11000       result = NULL;
11001       break;
11002     }
11003
11004   if (result)
11005     return result;
11006
11007   snprintf (buff, sizeof buff, _("<other>: %x"), other);
11008   return buff;
11009 }
11010
11011 static const char *
11012 get_symbol_index_type (Filedata * filedata, unsigned int type)
11013 {
11014   static char buff[32];
11015
11016   switch (type)
11017     {
11018     case SHN_UNDEF:     return "UND";
11019     case SHN_ABS:       return "ABS";
11020     case SHN_COMMON:    return "COM";
11021     default:
11022       if (type == SHN_IA_64_ANSI_COMMON
11023           && filedata->file_header.e_machine == EM_IA_64
11024           && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11025         return "ANSI_COM";
11026       else if ((filedata->file_header.e_machine == EM_X86_64
11027                 || filedata->file_header.e_machine == EM_L1OM
11028                 || filedata->file_header.e_machine == EM_K1OM)
11029                && type == SHN_X86_64_LCOMMON)
11030         return "LARGE_COM";
11031       else if ((type == SHN_MIPS_SCOMMON
11032                 && filedata->file_header.e_machine == EM_MIPS)
11033                || (type == SHN_TIC6X_SCOMMON
11034                    && filedata->file_header.e_machine == EM_TI_C6000))
11035         return "SCOM";
11036       else if (type == SHN_MIPS_SUNDEFINED
11037                && filedata->file_header.e_machine == EM_MIPS)
11038         return "SUND";
11039       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11040         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11041       else if (type >= SHN_LOOS && type <= SHN_HIOS)
11042         sprintf (buff, "OS [0x%04x]", type & 0xffff);
11043       else if (type >= SHN_LORESERVE)
11044         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11045       else if (type >= filedata->file_header.e_shnum)
11046         sprintf (buff, _("bad section index[%3d]"), type);
11047       else
11048         sprintf (buff, "%3d", type);
11049       break;
11050     }
11051
11052   return buff;
11053 }
11054
11055 static bfd_vma *
11056 get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
11057 {
11058   unsigned char * e_data;
11059   bfd_vma * i_data;
11060
11061   /* If the size_t type is smaller than the bfd_size_type, eg because
11062      you are building a 32-bit tool on a 64-bit host, then make sure
11063      that when (number) is cast to (size_t) no information is lost.  */
11064   if (sizeof (size_t) < sizeof (bfd_size_type)
11065       && (bfd_size_type) ((size_t) number) != number)
11066     {
11067       error (_("Size truncation prevents reading %s elements of size %u\n"),
11068              bfd_vmatoa ("u", number), ent_size);
11069       return NULL;
11070     }
11071
11072   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11073      attempting to allocate memory when the read is bound to fail.  */
11074   if (ent_size * number > filedata->file_size)
11075     {
11076       error (_("Invalid number of dynamic entries: %s\n"),
11077              bfd_vmatoa ("u", number));
11078       return NULL;
11079     }
11080
11081   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11082   if (e_data == NULL)
11083     {
11084       error (_("Out of memory reading %s dynamic entries\n"),
11085              bfd_vmatoa ("u", number));
11086       return NULL;
11087     }
11088
11089   if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
11090     {
11091       error (_("Unable to read in %s bytes of dynamic data\n"),
11092              bfd_vmatoa ("u", number * ent_size));
11093       free (e_data);
11094       return NULL;
11095     }
11096
11097   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11098   if (i_data == NULL)
11099     {
11100       error (_("Out of memory allocating space for %s dynamic entries\n"),
11101              bfd_vmatoa ("u", number));
11102       free (e_data);
11103       return NULL;
11104     }
11105
11106   while (number--)
11107     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11108
11109   free (e_data);
11110
11111   return i_data;
11112 }
11113
11114 static void
11115 print_dynamic_symbol (Filedata * filedata, bfd_vma si, unsigned long hn)
11116 {
11117   Elf_Internal_Sym * psym;
11118   int n;
11119
11120   n = print_vma (si, DEC_5);
11121   if (n < 5)
11122     fputs (&"     "[n], stdout);
11123   printf (" %3lu: ", hn);
11124
11125   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11126     {
11127       printf (_("<No info available for dynamic symbol number %lu>\n"),
11128               (unsigned long) si);
11129       return;
11130     }
11131
11132   psym = dynamic_symbols + si;
11133   print_vma (psym->st_value, LONG_HEX);
11134   putchar (' ');
11135   print_vma (psym->st_size, DEC_5);
11136
11137   printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11138   printf (" %-6s",  get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11139
11140   if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11141     printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11142   else
11143     {
11144       unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11145
11146       printf (" %-7s",  get_symbol_visibility (vis));
11147       /* Check to see if any other bits in the st_other field are set.
11148          Note - displaying this information disrupts the layout of the
11149          table being generated, but for the moment this case is very
11150          rare.  */
11151       if (psym->st_other ^ vis)
11152         printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11153     }
11154
11155   printf (" %3.3s ", get_symbol_index_type (filedata, psym->st_shndx));
11156   if (VALID_DYNAMIC_NAME (psym->st_name))
11157     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11158   else
11159     printf (_(" <corrupt: %14ld>"), psym->st_name);
11160   putchar ('\n');
11161 }
11162
11163 static const char *
11164 get_symbol_version_string (Filedata *                   filedata,
11165                            bfd_boolean                  is_dynsym,
11166                            const char *                 strtab,
11167                            unsigned long int            strtab_size,
11168                            unsigned int                 si,
11169                            Elf_Internal_Sym *           psym,
11170                            enum versioned_symbol_info * sym_info,
11171                            unsigned short *             vna_other)
11172 {
11173   unsigned char data[2];
11174   unsigned short vers_data;
11175   unsigned long offset;
11176
11177   if (!is_dynsym
11178       || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11179     return NULL;
11180
11181   offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11182                             sizeof data + si * sizeof (vers_data));
11183
11184   if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11185                 sizeof (data), 1, _("version data")) == NULL)
11186     return NULL;
11187
11188   vers_data = byte_get (data, 2);
11189
11190   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
11191     return NULL;
11192
11193   /* Usually we'd only see verdef for defined symbols, and verneed for
11194      undefined symbols.  However, symbols defined by the linker in
11195      .dynbss for variables copied from a shared library in order to
11196      avoid text relocations are defined yet have verneed.  We could
11197      use a heuristic to detect the special case, for example, check
11198      for verneed first on symbols defined in SHT_NOBITS sections, but
11199      it is simpler and more reliable to just look for both verdef and
11200      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
11201
11202   if (psym->st_shndx != SHN_UNDEF
11203       && vers_data != 0x8001
11204       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11205     {
11206       Elf_Internal_Verdef ivd;
11207       Elf_Internal_Verdaux ivda;
11208       Elf_External_Verdaux evda;
11209       unsigned long off;
11210
11211       off = offset_from_vma (filedata,
11212                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11213                              sizeof (Elf_External_Verdef));
11214
11215       do
11216         {
11217           Elf_External_Verdef evd;
11218
11219           if (get_data (&evd, filedata, off, sizeof (evd), 1,
11220                         _("version def")) == NULL)
11221             {
11222               ivd.vd_ndx = 0;
11223               ivd.vd_aux = 0;
11224               ivd.vd_next = 0;
11225             }
11226           else
11227             {
11228               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11229               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11230               ivd.vd_next = BYTE_GET (evd.vd_next);
11231             }
11232
11233           off += ivd.vd_next;
11234         }
11235       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11236
11237       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11238         {
11239           off -= ivd.vd_next;
11240           off += ivd.vd_aux;
11241
11242           if (get_data (&evda, filedata, off, sizeof (evda), 1,
11243                         _("version def aux")) != NULL)
11244             {
11245               ivda.vda_name = BYTE_GET (evda.vda_name);
11246
11247               if (psym->st_name != ivda.vda_name)
11248                 {
11249                   *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11250                                ? symbol_hidden : symbol_public);
11251                   return (ivda.vda_name < strtab_size
11252                           ? strtab + ivda.vda_name : _("<corrupt>"));
11253                 }
11254             }
11255         }
11256     }
11257
11258   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11259     {
11260       Elf_External_Verneed evn;
11261       Elf_Internal_Verneed ivn;
11262       Elf_Internal_Vernaux ivna;
11263
11264       offset = offset_from_vma (filedata,
11265                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11266                                 sizeof evn);
11267       do
11268         {
11269           unsigned long vna_off;
11270
11271           if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11272                         _("version need")) == NULL)
11273             {
11274               ivna.vna_next = 0;
11275               ivna.vna_other = 0;
11276               ivna.vna_name = 0;
11277               break;
11278             }
11279
11280           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
11281           ivn.vn_next = BYTE_GET (evn.vn_next);
11282
11283           vna_off = offset + ivn.vn_aux;
11284
11285           do
11286             {
11287               Elf_External_Vernaux evna;
11288
11289               if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11290                             _("version need aux (3)")) == NULL)
11291                 {
11292                   ivna.vna_next = 0;
11293                   ivna.vna_other = 0;
11294                   ivna.vna_name = 0;
11295                 }
11296               else
11297                 {
11298                   ivna.vna_other = BYTE_GET (evna.vna_other);
11299                   ivna.vna_next  = BYTE_GET (evna.vna_next);
11300                   ivna.vna_name  = BYTE_GET (evna.vna_name);
11301                 }
11302
11303               vna_off += ivna.vna_next;
11304             }
11305           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11306
11307           if (ivna.vna_other == vers_data)
11308             break;
11309
11310           offset += ivn.vn_next;
11311         }
11312       while (ivn.vn_next != 0);
11313
11314       if (ivna.vna_other == vers_data)
11315         {
11316           *sym_info = symbol_undefined;
11317           *vna_other = ivna.vna_other;
11318           return (ivna.vna_name < strtab_size
11319                   ? strtab + ivna.vna_name : _("<corrupt>"));
11320         }
11321     }
11322   return NULL;
11323 }
11324
11325 /* Dump the symbol table.  */
11326 static bfd_boolean
11327 process_symbol_table (Filedata * filedata)
11328 {
11329   Elf_Internal_Shdr * section;
11330   bfd_size_type nbuckets = 0;
11331   bfd_size_type nchains = 0;
11332   bfd_vma * buckets = NULL;
11333   bfd_vma * chains = NULL;
11334   bfd_vma ngnubuckets = 0;
11335   bfd_vma * gnubuckets = NULL;
11336   bfd_vma * gnuchains = NULL;
11337   bfd_vma gnusymidx = 0;
11338   bfd_size_type ngnuchains = 0;
11339
11340   if (!do_syms && !do_dyn_syms && !do_histogram)
11341     return TRUE;
11342
11343   if (dynamic_info[DT_HASH]
11344       && (do_histogram
11345           || (do_using_dynamic
11346               && !do_dyn_syms
11347               && dynamic_strings != NULL)))
11348     {
11349       unsigned char nb[8];
11350       unsigned char nc[8];
11351       unsigned int hash_ent_size = 4;
11352
11353       if ((filedata->file_header.e_machine == EM_ALPHA
11354            || filedata->file_header.e_machine == EM_S390
11355            || filedata->file_header.e_machine == EM_S390_OLD)
11356           && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11357         hash_ent_size = 8;
11358
11359       if (fseek (filedata->handle,
11360                  (archive_file_offset
11361                   + offset_from_vma (filedata, dynamic_info[DT_HASH],
11362                                      sizeof nb + sizeof nc)),
11363                  SEEK_SET))
11364         {
11365           error (_("Unable to seek to start of dynamic information\n"));
11366           goto no_hash;
11367         }
11368
11369       if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11370         {
11371           error (_("Failed to read in number of buckets\n"));
11372           goto no_hash;
11373         }
11374
11375       if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11376         {
11377           error (_("Failed to read in number of chains\n"));
11378           goto no_hash;
11379         }
11380
11381       nbuckets = byte_get (nb, hash_ent_size);
11382       nchains  = byte_get (nc, hash_ent_size);
11383
11384       buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11385       chains  = get_dynamic_data (filedata, nchains, hash_ent_size);
11386
11387     no_hash:
11388       if (buckets == NULL || chains == NULL)
11389         {
11390           if (do_using_dynamic)
11391             return FALSE;
11392           free (buckets);
11393           free (chains);
11394           buckets = NULL;
11395           chains = NULL;
11396           nbuckets = 0;
11397           nchains = 0;
11398         }
11399     }
11400
11401   if (dynamic_info_DT_GNU_HASH
11402       && (do_histogram
11403           || (do_using_dynamic
11404               && !do_dyn_syms
11405               && dynamic_strings != NULL)))
11406     {
11407       unsigned char nb[16];
11408       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11409       bfd_vma buckets_vma;
11410
11411       if (fseek (filedata->handle,
11412                  (archive_file_offset
11413                   + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11414                                      sizeof nb)),
11415                  SEEK_SET))
11416         {
11417           error (_("Unable to seek to start of dynamic information\n"));
11418           goto no_gnu_hash;
11419         }
11420
11421       if (fread (nb, 16, 1, filedata->handle) != 1)
11422         {
11423           error (_("Failed to read in number of buckets\n"));
11424           goto no_gnu_hash;
11425         }
11426
11427       ngnubuckets = byte_get (nb, 4);
11428       gnusymidx = byte_get (nb + 4, 4);
11429       bitmaskwords = byte_get (nb + 8, 4);
11430       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11431       if (is_32bit_elf)
11432         buckets_vma += bitmaskwords * 4;
11433       else
11434         buckets_vma += bitmaskwords * 8;
11435
11436       if (fseek (filedata->handle,
11437                  (archive_file_offset
11438                   + offset_from_vma (filedata, buckets_vma, 4)),
11439                  SEEK_SET))
11440         {
11441           error (_("Unable to seek to start of dynamic information\n"));
11442           goto no_gnu_hash;
11443         }
11444
11445       gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11446
11447       if (gnubuckets == NULL)
11448         goto no_gnu_hash;
11449
11450       for (i = 0; i < ngnubuckets; i++)
11451         if (gnubuckets[i] != 0)
11452           {
11453             if (gnubuckets[i] < gnusymidx)
11454               return FALSE;
11455
11456             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11457               maxchain = gnubuckets[i];
11458           }
11459
11460       if (maxchain == 0xffffffff)
11461         goto no_gnu_hash;
11462
11463       maxchain -= gnusymidx;
11464
11465       if (fseek (filedata->handle,
11466                  (archive_file_offset
11467                   + offset_from_vma (filedata, buckets_vma
11468                                            + 4 * (ngnubuckets + maxchain), 4)),
11469                  SEEK_SET))
11470         {
11471           error (_("Unable to seek to start of dynamic information\n"));
11472           goto no_gnu_hash;
11473         }
11474
11475       do
11476         {
11477           if (fread (nb, 4, 1, filedata->handle) != 1)
11478             {
11479               error (_("Failed to determine last chain length\n"));
11480               goto no_gnu_hash;
11481             }
11482
11483           if (maxchain + 1 == 0)
11484             goto no_gnu_hash;
11485
11486           ++maxchain;
11487         }
11488       while ((byte_get (nb, 4) & 1) == 0);
11489
11490       if (fseek (filedata->handle,
11491                  (archive_file_offset
11492                   + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11493                  SEEK_SET))
11494         {
11495           error (_("Unable to seek to start of dynamic information\n"));
11496           goto no_gnu_hash;
11497         }
11498
11499       gnuchains = get_dynamic_data (filedata, maxchain, 4);
11500       ngnuchains = maxchain;
11501
11502     no_gnu_hash:
11503       if (gnuchains == NULL)
11504         {
11505           free (gnubuckets);
11506           gnubuckets = NULL;
11507           ngnubuckets = 0;
11508           if (do_using_dynamic)
11509             return FALSE;
11510         }
11511     }
11512
11513   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11514       && do_syms
11515       && do_using_dynamic
11516       && dynamic_strings != NULL
11517       && dynamic_symbols != NULL)
11518     {
11519       unsigned long hn;
11520
11521       if (dynamic_info[DT_HASH])
11522         {
11523           bfd_vma si;
11524           char *visited;
11525
11526           printf (_("\nSymbol table for image:\n"));
11527           if (is_32bit_elf)
11528             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11529           else
11530             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11531
11532           visited = xcmalloc (nchains, 1);
11533           memset (visited, 0, nchains);
11534           for (hn = 0; hn < nbuckets; hn++)
11535             {
11536               for (si = buckets[hn]; si > 0; si = chains[si])
11537                 {
11538                   print_dynamic_symbol (filedata, si, hn);
11539                   if (si >= nchains || visited[si])
11540                     {
11541                       error (_("histogram chain is corrupt\n"));
11542                       break;
11543                     }
11544                   visited[si] = 1;
11545                 }
11546             }
11547           free (visited);
11548         }
11549
11550       if (dynamic_info_DT_GNU_HASH)
11551         {
11552           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11553           if (is_32bit_elf)
11554             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11555           else
11556             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11557
11558           for (hn = 0; hn < ngnubuckets; ++hn)
11559             if (gnubuckets[hn] != 0)
11560               {
11561                 bfd_vma si = gnubuckets[hn];
11562                 bfd_vma off = si - gnusymidx;
11563
11564                 do
11565                   {
11566                     print_dynamic_symbol (filedata, si, hn);
11567                     si++;
11568                   }
11569                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11570               }
11571         }
11572     }
11573   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11574            && filedata->section_headers != NULL)
11575     {
11576       unsigned int i;
11577
11578       for (i = 0, section = filedata->section_headers;
11579            i < filedata->file_header.e_shnum;
11580            i++, section++)
11581         {
11582           unsigned int si;
11583           char * strtab = NULL;
11584           unsigned long int strtab_size = 0;
11585           Elf_Internal_Sym * symtab;
11586           Elf_Internal_Sym * psym;
11587           unsigned long num_syms;
11588
11589           if ((section->sh_type != SHT_SYMTAB
11590                && section->sh_type != SHT_DYNSYM)
11591               || (!do_syms
11592                   && section->sh_type == SHT_SYMTAB))
11593             continue;
11594
11595           if (section->sh_entsize == 0)
11596             {
11597               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11598                       printable_section_name (filedata, section));
11599               continue;
11600             }
11601
11602           num_syms = section->sh_size / section->sh_entsize;
11603           printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11604                             "\nSymbol table '%s' contains %lu entries:\n",
11605                             num_syms),
11606                   printable_section_name (filedata, section),
11607                   num_syms);
11608
11609           if (is_32bit_elf)
11610             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
11611           else
11612             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
11613
11614           symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
11615           if (symtab == NULL)
11616             continue;
11617
11618           if (section->sh_link == filedata->file_header.e_shstrndx)
11619             {
11620               strtab = filedata->string_table;
11621               strtab_size = filedata->string_table_length;
11622             }
11623           else if (section->sh_link < filedata->file_header.e_shnum)
11624             {
11625               Elf_Internal_Shdr * string_sec;
11626
11627               string_sec = filedata->section_headers + section->sh_link;
11628
11629               strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
11630                                           1, string_sec->sh_size,
11631                                           _("string table"));
11632               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11633             }
11634
11635           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11636             {
11637               const char *version_string;
11638               enum versioned_symbol_info sym_info;
11639               unsigned short vna_other;
11640
11641               printf ("%6d: ", si);
11642               print_vma (psym->st_value, LONG_HEX);
11643               putchar (' ');
11644               print_vma (psym->st_size, DEC_5);
11645               printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11646               printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11647               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11648                 printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11649               else
11650                 {
11651                   unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11652
11653                   printf (" %-7s", get_symbol_visibility (vis));
11654                   /* Check to see if any other bits in the st_other field are set.
11655                      Note - displaying this information disrupts the layout of the
11656                      table being generated, but for the moment this case is very rare.  */
11657                   if (psym->st_other ^ vis)
11658                     printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11659                 }
11660               printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
11661               print_symbol (25, psym->st_name < strtab_size
11662                             ? strtab + psym->st_name : _("<corrupt>"));
11663
11664               version_string
11665                 = get_symbol_version_string (filedata,
11666                                              section->sh_type == SHT_DYNSYM,
11667                                              strtab, strtab_size, si,
11668                                              psym, &sym_info, &vna_other);
11669               if (version_string)
11670                 {
11671                   if (sym_info == symbol_undefined)
11672                     printf ("@%s (%d)", version_string, vna_other);
11673                   else
11674                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11675                             version_string);
11676                 }
11677
11678               putchar ('\n');
11679
11680               if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11681                   && si >= section->sh_info
11682                   /* Irix 5 and 6 MIPS binaries are known to ignore this requirement.  */
11683                   && filedata->file_header.e_machine != EM_MIPS
11684                   /* Solaris binaries have been found to violate this requirement as
11685                      well.  Not sure if this is a bug or an ABI requirement.  */
11686                   && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11687                 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11688                       si, printable_section_name (filedata, section), section->sh_info);
11689             }
11690
11691           free (symtab);
11692           if (strtab != filedata->string_table)
11693             free (strtab);
11694         }
11695     }
11696   else if (do_syms)
11697     printf
11698       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11699
11700   if (do_histogram && buckets != NULL)
11701     {
11702       unsigned long * lengths;
11703       unsigned long * counts;
11704       unsigned long hn;
11705       bfd_vma si;
11706       unsigned long maxlength = 0;
11707       unsigned long nzero_counts = 0;
11708       unsigned long nsyms = 0;
11709       char *visited;
11710
11711       printf (ngettext ("\nHistogram for bucket list length "
11712                         "(total of %lu bucket):\n",
11713                         "\nHistogram for bucket list length "
11714                         "(total of %lu buckets):\n",
11715                         (unsigned long) nbuckets),
11716               (unsigned long) nbuckets);
11717
11718       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11719       if (lengths == NULL)
11720         {
11721           error (_("Out of memory allocating space for histogram buckets\n"));
11722           return FALSE;
11723         }
11724       visited = xcmalloc (nchains, 1);
11725       memset (visited, 0, nchains);
11726
11727       printf (_(" Length  Number     %% of total  Coverage\n"));
11728       for (hn = 0; hn < nbuckets; ++hn)
11729         {
11730           for (si = buckets[hn]; si > 0; si = chains[si])
11731             {
11732               ++nsyms;
11733               if (maxlength < ++lengths[hn])
11734                 ++maxlength;
11735               if (si >= nchains || visited[si])
11736                 {
11737                   error (_("histogram chain is corrupt\n"));
11738                   break;
11739                 }
11740               visited[si] = 1;
11741             }
11742         }
11743       free (visited);
11744
11745       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11746       if (counts == NULL)
11747         {
11748           free (lengths);
11749           error (_("Out of memory allocating space for histogram counts\n"));
11750           return FALSE;
11751         }
11752
11753       for (hn = 0; hn < nbuckets; ++hn)
11754         ++counts[lengths[hn]];
11755
11756       if (nbuckets > 0)
11757         {
11758           unsigned long i;
11759           printf ("      0  %-10lu (%5.1f%%)\n",
11760                   counts[0], (counts[0] * 100.0) / nbuckets);
11761           for (i = 1; i <= maxlength; ++i)
11762             {
11763               nzero_counts += counts[i] * i;
11764               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11765                       i, counts[i], (counts[i] * 100.0) / nbuckets,
11766                       (nzero_counts * 100.0) / nsyms);
11767             }
11768         }
11769
11770       free (counts);
11771       free (lengths);
11772     }
11773
11774   if (buckets != NULL)
11775     {
11776       free (buckets);
11777       free (chains);
11778     }
11779
11780   if (do_histogram && gnubuckets != NULL)
11781     {
11782       unsigned long * lengths;
11783       unsigned long * counts;
11784       unsigned long hn;
11785       unsigned long maxlength = 0;
11786       unsigned long nzero_counts = 0;
11787       unsigned long nsyms = 0;
11788
11789       printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11790                         "(total of %lu bucket):\n",
11791                         "\nHistogram for `.gnu.hash' bucket list length "
11792                         "(total of %lu buckets):\n",
11793                         (unsigned long) ngnubuckets),
11794               (unsigned long) ngnubuckets);
11795
11796       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11797       if (lengths == NULL)
11798         {
11799           error (_("Out of memory allocating space for gnu histogram buckets\n"));
11800           return FALSE;
11801         }
11802
11803       printf (_(" Length  Number     %% of total  Coverage\n"));
11804
11805       for (hn = 0; hn < ngnubuckets; ++hn)
11806         if (gnubuckets[hn] != 0)
11807           {
11808             bfd_vma off, length = 1;
11809
11810             for (off = gnubuckets[hn] - gnusymidx;
11811                  /* PR 17531 file: 010-77222-0.004.  */
11812                  off < ngnuchains && (gnuchains[off] & 1) == 0;
11813                  ++off)
11814               ++length;
11815             lengths[hn] = length;
11816             if (length > maxlength)
11817               maxlength = length;
11818             nsyms += length;
11819           }
11820
11821       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11822       if (counts == NULL)
11823         {
11824           free (lengths);
11825           error (_("Out of memory allocating space for gnu histogram counts\n"));
11826           return FALSE;
11827         }
11828
11829       for (hn = 0; hn < ngnubuckets; ++hn)
11830         ++counts[lengths[hn]];
11831
11832       if (ngnubuckets > 0)
11833         {
11834           unsigned long j;
11835           printf ("      0  %-10lu (%5.1f%%)\n",
11836                   counts[0], (counts[0] * 100.0) / ngnubuckets);
11837           for (j = 1; j <= maxlength; ++j)
11838             {
11839               nzero_counts += counts[j] * j;
11840               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11841                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11842                       (nzero_counts * 100.0) / nsyms);
11843             }
11844         }
11845
11846       free (counts);
11847       free (lengths);
11848       free (gnubuckets);
11849       free (gnuchains);
11850     }
11851
11852   return TRUE;
11853 }
11854
11855 static bfd_boolean
11856 process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
11857 {
11858   unsigned int i;
11859
11860   if (dynamic_syminfo == NULL
11861       || !do_dynamic)
11862     /* No syminfo, this is ok.  */
11863     return TRUE;
11864
11865   /* There better should be a dynamic symbol section.  */
11866   if (dynamic_symbols == NULL || dynamic_strings == NULL)
11867     return FALSE;
11868
11869   if (dynamic_addr)
11870     printf (ngettext ("\nDynamic info segment at offset 0x%lx "
11871                       "contains %d entry:\n",
11872                       "\nDynamic info segment at offset 0x%lx "
11873                       "contains %d entries:\n",
11874                       dynamic_syminfo_nent),
11875             dynamic_syminfo_offset, dynamic_syminfo_nent);
11876
11877   printf (_(" Num: Name                           BoundTo     Flags\n"));
11878   for (i = 0; i < dynamic_syminfo_nent; ++i)
11879     {
11880       unsigned short int flags = dynamic_syminfo[i].si_flags;
11881
11882       printf ("%4d: ", i);
11883       if (i >= num_dynamic_syms)
11884         printf (_("<corrupt index>"));
11885       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
11886         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11887       else
11888         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
11889       putchar (' ');
11890
11891       switch (dynamic_syminfo[i].si_boundto)
11892         {
11893         case SYMINFO_BT_SELF:
11894           fputs ("SELF       ", stdout);
11895           break;
11896         case SYMINFO_BT_PARENT:
11897           fputs ("PARENT     ", stdout);
11898           break;
11899         default:
11900           if (dynamic_syminfo[i].si_boundto > 0
11901               && dynamic_syminfo[i].si_boundto < dynamic_nent
11902               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
11903             {
11904               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
11905               putchar (' ' );
11906             }
11907           else
11908             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11909           break;
11910         }
11911
11912       if (flags & SYMINFO_FLG_DIRECT)
11913         printf (" DIRECT");
11914       if (flags & SYMINFO_FLG_PASSTHRU)
11915         printf (" PASSTHRU");
11916       if (flags & SYMINFO_FLG_COPY)
11917         printf (" COPY");
11918       if (flags & SYMINFO_FLG_LAZYLOAD)
11919         printf (" LAZYLOAD");
11920
11921       puts ("");
11922     }
11923
11924   return TRUE;
11925 }
11926
11927 #define IN_RANGE(START,END,ADDR,OFF)            \
11928   (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11929
11930 /* Check to see if the given reloc needs to be handled in a target specific
11931    manner.  If so then process the reloc and return TRUE otherwise return
11932    FALSE.
11933
11934    If called with reloc == NULL, then this is a signal that reloc processing
11935    for the current section has finished, and any saved state should be
11936    discarded.  */
11937
11938 static bfd_boolean
11939 target_specific_reloc_handling (Filedata *           filedata,
11940                                 Elf_Internal_Rela *  reloc,
11941                                 unsigned char *      start,
11942                                 unsigned char *      end,
11943                                 Elf_Internal_Sym *   symtab,
11944                                 unsigned long        num_syms)
11945 {
11946   unsigned int reloc_type = 0;
11947   unsigned long sym_index = 0;
11948
11949   if (reloc)
11950     {
11951       reloc_type = get_reloc_type (filedata, reloc->r_info);
11952       sym_index = get_reloc_symindex (reloc->r_info);
11953     }
11954
11955   switch (filedata->file_header.e_machine)
11956     {
11957     case EM_MSP430:
11958     case EM_MSP430_OLD:
11959       {
11960         static Elf_Internal_Sym * saved_sym = NULL;
11961
11962         if (reloc == NULL)
11963           {
11964             saved_sym = NULL;
11965             return TRUE;
11966           }
11967
11968         switch (reloc_type)
11969           {
11970           case 10: /* R_MSP430_SYM_DIFF */
11971             if (uses_msp430x_relocs (filedata))
11972               break;
11973             /* Fall through.  */
11974           case 21: /* R_MSP430X_SYM_DIFF */
11975             /* PR 21139.  */
11976             if (sym_index >= num_syms)
11977               error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11978                      sym_index);
11979             else
11980               saved_sym = symtab + sym_index;
11981             return TRUE;
11982
11983           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11984           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11985             goto handle_sym_diff;
11986
11987           case 5: /* R_MSP430_16_BYTE */
11988           case 9: /* R_MSP430_8 */
11989             if (uses_msp430x_relocs (filedata))
11990               break;
11991             goto handle_sym_diff;
11992
11993           case 2: /* R_MSP430_ABS16 */
11994           case 15: /* R_MSP430X_ABS16 */
11995             if (! uses_msp430x_relocs (filedata))
11996               break;
11997             goto handle_sym_diff;
11998
11999           handle_sym_diff:
12000             if (saved_sym != NULL)
12001               {
12002                 int reloc_size = reloc_type == 1 ? 4 : 2;
12003                 bfd_vma value;
12004
12005                 if (sym_index >= num_syms)
12006                   error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12007                          sym_index);
12008                 else
12009                   {
12010                     value = reloc->r_addend + (symtab[sym_index].st_value
12011                                                - saved_sym->st_value);
12012
12013                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12014                       byte_put (start + reloc->r_offset, value, reloc_size);
12015                     else
12016                       /* PR 21137 */
12017                       error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12018                              (long) reloc->r_offset);
12019                   }
12020
12021                 saved_sym = NULL;
12022                 return TRUE;
12023               }
12024             break;
12025
12026           default:
12027             if (saved_sym != NULL)
12028               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12029             break;
12030           }
12031         break;
12032       }
12033
12034     case EM_MN10300:
12035     case EM_CYGNUS_MN10300:
12036       {
12037         static Elf_Internal_Sym * saved_sym = NULL;
12038
12039         if (reloc == NULL)
12040           {
12041             saved_sym = NULL;
12042             return TRUE;
12043           }
12044
12045         switch (reloc_type)
12046           {
12047           case 34: /* R_MN10300_ALIGN */
12048             return TRUE;
12049           case 33: /* R_MN10300_SYM_DIFF */
12050             if (sym_index >= num_syms)
12051               error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12052                      sym_index);
12053             else
12054               saved_sym = symtab + sym_index;
12055             return TRUE;
12056
12057           case 1: /* R_MN10300_32 */
12058           case 2: /* R_MN10300_16 */
12059             if (saved_sym != NULL)
12060               {
12061                 int reloc_size = reloc_type == 1 ? 4 : 2;
12062                 bfd_vma value;
12063
12064                 if (sym_index >= num_syms)
12065                   error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12066                          sym_index);
12067                 else
12068                   {
12069                     value = reloc->r_addend + (symtab[sym_index].st_value
12070                                                - saved_sym->st_value);
12071
12072                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12073                       byte_put (start + reloc->r_offset, value, reloc_size);
12074                     else
12075                       error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12076                              (long) reloc->r_offset);
12077                   }
12078
12079                 saved_sym = NULL;
12080                 return TRUE;
12081               }
12082             break;
12083           default:
12084             if (saved_sym != NULL)
12085               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12086             break;
12087           }
12088         break;
12089       }
12090
12091     case EM_RL78:
12092       {
12093         static bfd_vma saved_sym1 = 0;
12094         static bfd_vma saved_sym2 = 0;
12095         static bfd_vma value;
12096
12097         if (reloc == NULL)
12098           {
12099             saved_sym1 = saved_sym2 = 0;
12100             return TRUE;
12101           }
12102
12103         switch (reloc_type)
12104           {
12105           case 0x80: /* R_RL78_SYM.  */
12106             saved_sym1 = saved_sym2;
12107             if (sym_index >= num_syms)
12108               error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12109                      sym_index);
12110             else
12111               {
12112                 saved_sym2 = symtab[sym_index].st_value;
12113                 saved_sym2 += reloc->r_addend;
12114               }
12115             return TRUE;
12116
12117           case 0x83: /* R_RL78_OPsub.  */
12118             value = saved_sym1 - saved_sym2;
12119             saved_sym2 = saved_sym1 = 0;
12120             return TRUE;
12121             break;
12122
12123           case 0x41: /* R_RL78_ABS32.  */
12124             if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12125               byte_put (start + reloc->r_offset, value, 4);
12126             else
12127               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12128                      (long) reloc->r_offset);
12129             value = 0;
12130             return TRUE;
12131
12132           case 0x43: /* R_RL78_ABS16.  */
12133             if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12134               byte_put (start + reloc->r_offset, value, 2);
12135             else
12136               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12137                      (long) reloc->r_offset);
12138             value = 0;
12139             return TRUE;
12140
12141           default:
12142             break;
12143           }
12144         break;
12145       }
12146     }
12147
12148   return FALSE;
12149 }
12150
12151 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12152    DWARF debug sections.  This is a target specific test.  Note - we do not
12153    go through the whole including-target-headers-multiple-times route, (as
12154    we have already done with <elf/h8.h>) because this would become very
12155    messy and even then this function would have to contain target specific
12156    information (the names of the relocs instead of their numeric values).
12157    FIXME: This is not the correct way to solve this problem.  The proper way
12158    is to have target specific reloc sizing and typing functions created by
12159    the reloc-macros.h header, in the same way that it already creates the
12160    reloc naming functions.  */
12161
12162 static bfd_boolean
12163 is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12164 {
12165   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12166   switch (filedata->file_header.e_machine)
12167     {
12168     case EM_386:
12169     case EM_IAMCU:
12170       return reloc_type == 1; /* R_386_32.  */
12171     case EM_68K:
12172       return reloc_type == 1; /* R_68K_32.  */
12173     case EM_860:
12174       return reloc_type == 1; /* R_860_32.  */
12175     case EM_960:
12176       return reloc_type == 2; /* R_960_32.  */
12177     case EM_AARCH64:
12178       return (reloc_type == 258
12179               || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12180     case EM_ADAPTEVA_EPIPHANY:
12181       return reloc_type == 3;
12182     case EM_ALPHA:
12183       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
12184     case EM_ARC:
12185       return reloc_type == 1; /* R_ARC_32.  */
12186     case EM_ARC_COMPACT:
12187     case EM_ARC_COMPACT2:
12188       return reloc_type == 4; /* R_ARC_32.  */
12189     case EM_ARM:
12190       return reloc_type == 2; /* R_ARM_ABS32 */
12191     case EM_AVR_OLD:
12192     case EM_AVR:
12193       return reloc_type == 1;
12194     case EM_BLACKFIN:
12195       return reloc_type == 0x12; /* R_byte4_data.  */
12196     case EM_CRIS:
12197       return reloc_type == 3; /* R_CRIS_32.  */
12198     case EM_CR16:
12199       return reloc_type == 3; /* R_CR16_NUM32.  */
12200     case EM_CRX:
12201       return reloc_type == 15; /* R_CRX_NUM32.  */
12202     case EM_CYGNUS_FRV:
12203       return reloc_type == 1;
12204     case EM_CYGNUS_D10V:
12205     case EM_D10V:
12206       return reloc_type == 6; /* R_D10V_32.  */
12207     case EM_CYGNUS_D30V:
12208     case EM_D30V:
12209       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
12210     case EM_DLX:
12211       return reloc_type == 3; /* R_DLX_RELOC_32.  */
12212     case EM_CYGNUS_FR30:
12213     case EM_FR30:
12214       return reloc_type == 3; /* R_FR30_32.  */
12215     case EM_FT32:
12216       return reloc_type == 1; /* R_FT32_32.  */
12217     case EM_H8S:
12218     case EM_H8_300:
12219     case EM_H8_300H:
12220       return reloc_type == 1; /* R_H8_DIR32.  */
12221     case EM_IA_64:
12222       return (reloc_type == 0x64    /* R_IA64_SECREL32MSB.  */
12223               || reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
12224               || reloc_type == 0x24 /* R_IA64_DIR32MSB.  */
12225               || reloc_type == 0x25 /* R_IA64_DIR32LSB.  */);
12226     case EM_IP2K_OLD:
12227     case EM_IP2K:
12228       return reloc_type == 2; /* R_IP2K_32.  */
12229     case EM_IQ2000:
12230       return reloc_type == 2; /* R_IQ2000_32.  */
12231     case EM_LATTICEMICO32:
12232       return reloc_type == 3; /* R_LM32_32.  */
12233     case EM_M32C_OLD:
12234     case EM_M32C:
12235       return reloc_type == 3; /* R_M32C_32.  */
12236     case EM_M32R:
12237       return reloc_type == 34; /* R_M32R_32_RELA.  */
12238     case EM_68HC11:
12239     case EM_68HC12:
12240       return reloc_type == 6; /* R_M68HC11_32.  */
12241     case EM_MCORE:
12242       return reloc_type == 1; /* R_MCORE_ADDR32.  */
12243     case EM_CYGNUS_MEP:
12244       return reloc_type == 4; /* R_MEP_32.  */
12245     case EM_METAG:
12246       return reloc_type == 2; /* R_METAG_ADDR32.  */
12247     case EM_MICROBLAZE:
12248       return reloc_type == 1; /* R_MICROBLAZE_32.  */
12249     case EM_MIPS:
12250       return reloc_type == 2; /* R_MIPS_32.  */
12251     case EM_MMIX:
12252       return reloc_type == 4; /* R_MMIX_32.  */
12253     case EM_CYGNUS_MN10200:
12254     case EM_MN10200:
12255       return reloc_type == 1; /* R_MN10200_32.  */
12256     case EM_CYGNUS_MN10300:
12257     case EM_MN10300:
12258       return reloc_type == 1; /* R_MN10300_32.  */
12259     case EM_MOXIE:
12260       return reloc_type == 1; /* R_MOXIE_32.  */
12261     case EM_MSP430_OLD:
12262     case EM_MSP430:
12263       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
12264     case EM_MT:
12265       return reloc_type == 2; /* R_MT_32.  */
12266     case EM_NDS32:
12267       return reloc_type == 20; /* R_NDS32_RELA.  */
12268     case EM_ALTERA_NIOS2:
12269       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
12270     case EM_NIOS32:
12271       return reloc_type == 1; /* R_NIOS_32.  */
12272     case EM_OR1K:
12273       return reloc_type == 1; /* R_OR1K_32.  */
12274     case EM_PARISC:
12275       return (reloc_type == 1 /* R_PARISC_DIR32.  */
12276               || reloc_type == 41); /* R_PARISC_SECREL32.  */
12277     case EM_PJ:
12278     case EM_PJ_OLD:
12279       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
12280     case EM_PPC64:
12281       return reloc_type == 1; /* R_PPC64_ADDR32.  */
12282     case EM_PPC:
12283       return reloc_type == 1; /* R_PPC_ADDR32.  */
12284     case EM_TI_PRU:
12285       return reloc_type == 11; /* R_PRU_BFD_RELOC_32.  */
12286     case EM_RISCV:
12287       return reloc_type == 1; /* R_RISCV_32.  */
12288     case EM_RL78:
12289       return reloc_type == 1; /* R_RL78_DIR32.  */
12290     case EM_RX:
12291       return reloc_type == 1; /* R_RX_DIR32.  */
12292     case EM_S370:
12293       return reloc_type == 1; /* R_I370_ADDR31.  */
12294     case EM_S390_OLD:
12295     case EM_S390:
12296       return reloc_type == 4; /* R_S390_32.  */
12297     case EM_SCORE:
12298       return reloc_type == 8; /* R_SCORE_ABS32.  */
12299     case EM_SH:
12300       return reloc_type == 1; /* R_SH_DIR32.  */
12301     case EM_SPARC32PLUS:
12302     case EM_SPARCV9:
12303     case EM_SPARC:
12304       return reloc_type == 3 /* R_SPARC_32.  */
12305         || reloc_type == 23; /* R_SPARC_UA32.  */
12306     case EM_SPU:
12307       return reloc_type == 6; /* R_SPU_ADDR32 */
12308     case EM_TI_C6000:
12309       return reloc_type == 1; /* R_C6000_ABS32.  */
12310     case EM_TILEGX:
12311       return reloc_type == 2; /* R_TILEGX_32.  */
12312     case EM_TILEPRO:
12313       return reloc_type == 1; /* R_TILEPRO_32.  */
12314     case EM_CYGNUS_V850:
12315     case EM_V850:
12316       return reloc_type == 6; /* R_V850_ABS32.  */
12317     case EM_V800:
12318       return reloc_type == 0x33; /* R_V810_WORD.  */
12319     case EM_VAX:
12320       return reloc_type == 1; /* R_VAX_32.  */
12321     case EM_VISIUM:
12322       return reloc_type == 3;  /* R_VISIUM_32. */
12323     case EM_WEBASSEMBLY:
12324       return reloc_type == 1;  /* R_WASM32_32.  */
12325     case EM_X86_64:
12326     case EM_L1OM:
12327     case EM_K1OM:
12328       return reloc_type == 10; /* R_X86_64_32.  */
12329     case EM_XC16X:
12330     case EM_C166:
12331       return reloc_type == 3; /* R_XC16C_ABS_32.  */
12332     case EM_XGATE:
12333       return reloc_type == 4; /* R_XGATE_32.  */
12334     case EM_XSTORMY16:
12335       return reloc_type == 1; /* R_XSTROMY16_32.  */
12336     case EM_XTENSA_OLD:
12337     case EM_XTENSA:
12338       return reloc_type == 1; /* R_XTENSA_32.  */
12339     default:
12340       {
12341         static unsigned int prev_warn = 0;
12342
12343         /* Avoid repeating the same warning multiple times.  */
12344         if (prev_warn != filedata->file_header.e_machine)
12345           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12346                  filedata->file_header.e_machine);
12347         prev_warn = filedata->file_header.e_machine;
12348         return FALSE;
12349       }
12350     }
12351 }
12352
12353 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12354    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
12355
12356 static bfd_boolean
12357 is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12358 {
12359   switch (filedata->file_header.e_machine)
12360   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12361     {
12362     case EM_386:
12363     case EM_IAMCU:
12364       return reloc_type == 2;  /* R_386_PC32.  */
12365     case EM_68K:
12366       return reloc_type == 4;  /* R_68K_PC32.  */
12367     case EM_AARCH64:
12368       return reloc_type == 261; /* R_AARCH64_PREL32 */
12369     case EM_ADAPTEVA_EPIPHANY:
12370       return reloc_type == 6;
12371     case EM_ALPHA:
12372       return reloc_type == 10; /* R_ALPHA_SREL32.  */
12373     case EM_ARC_COMPACT:
12374     case EM_ARC_COMPACT2:
12375       return reloc_type == 49; /* R_ARC_32_PCREL.  */
12376     case EM_ARM:
12377       return reloc_type == 3;  /* R_ARM_REL32 */
12378     case EM_AVR_OLD:
12379     case EM_AVR:
12380       return reloc_type == 36; /* R_AVR_32_PCREL.  */
12381     case EM_MICROBLAZE:
12382       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
12383     case EM_OR1K:
12384       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
12385     case EM_PARISC:
12386       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
12387     case EM_PPC:
12388       return reloc_type == 26; /* R_PPC_REL32.  */
12389     case EM_PPC64:
12390       return reloc_type == 26; /* R_PPC64_REL32.  */
12391     case EM_S390_OLD:
12392     case EM_S390:
12393       return reloc_type == 5;  /* R_390_PC32.  */
12394     case EM_SH:
12395       return reloc_type == 2;  /* R_SH_REL32.  */
12396     case EM_SPARC32PLUS:
12397     case EM_SPARCV9:
12398     case EM_SPARC:
12399       return reloc_type == 6;  /* R_SPARC_DISP32.  */
12400     case EM_SPU:
12401       return reloc_type == 13; /* R_SPU_REL32.  */
12402     case EM_TILEGX:
12403       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
12404     case EM_TILEPRO:
12405       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
12406     case EM_VISIUM:
12407       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
12408     case EM_X86_64:
12409     case EM_L1OM:
12410     case EM_K1OM:
12411       return reloc_type == 2;  /* R_X86_64_PC32.  */
12412     case EM_XTENSA_OLD:
12413     case EM_XTENSA:
12414       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
12415     default:
12416       /* Do not abort or issue an error message here.  Not all targets use
12417          pc-relative 32-bit relocs in their DWARF debug information and we
12418          have already tested for target coverage in is_32bit_abs_reloc.  A
12419          more helpful warning message will be generated by apply_relocations
12420          anyway, so just return.  */
12421       return FALSE;
12422     }
12423 }
12424
12425 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12426    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
12427
12428 static bfd_boolean
12429 is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12430 {
12431   switch (filedata->file_header.e_machine)
12432     {
12433     case EM_AARCH64:
12434       return reloc_type == 257; /* R_AARCH64_ABS64.  */
12435     case EM_ALPHA:
12436       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
12437     case EM_IA_64:
12438       return (reloc_type == 0x26    /* R_IA64_DIR64MSB.  */
12439               || reloc_type == 0x27 /* R_IA64_DIR64LSB.  */);
12440     case EM_PARISC:
12441       return reloc_type == 80; /* R_PARISC_DIR64.  */
12442     case EM_PPC64:
12443       return reloc_type == 38; /* R_PPC64_ADDR64.  */
12444     case EM_RISCV:
12445       return reloc_type == 2; /* R_RISCV_64.  */
12446     case EM_SPARC32PLUS:
12447     case EM_SPARCV9:
12448     case EM_SPARC:
12449       return reloc_type == 32 /* R_SPARC_64.  */
12450         || reloc_type == 54; /* R_SPARC_UA64.  */
12451     case EM_X86_64:
12452     case EM_L1OM:
12453     case EM_K1OM:
12454       return reloc_type == 1; /* R_X86_64_64.  */
12455     case EM_S390_OLD:
12456     case EM_S390:
12457       return reloc_type == 22;  /* R_S390_64.  */
12458     case EM_TILEGX:
12459       return reloc_type == 1; /* R_TILEGX_64.  */
12460     case EM_MIPS:
12461       return reloc_type == 18;  /* R_MIPS_64.  */
12462     default:
12463       return FALSE;
12464     }
12465 }
12466
12467 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12468    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
12469
12470 static bfd_boolean
12471 is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12472 {
12473   switch (filedata->file_header.e_machine)
12474     {
12475     case EM_AARCH64:
12476       return reloc_type == 260; /* R_AARCH64_PREL64.  */
12477     case EM_ALPHA:
12478       return reloc_type == 11; /* R_ALPHA_SREL64.  */
12479     case EM_IA_64:
12480       return (reloc_type == 0x4e    /* R_IA64_PCREL64MSB.  */
12481               || reloc_type == 0x4f /* R_IA64_PCREL64LSB.  */);
12482     case EM_PARISC:
12483       return reloc_type == 72; /* R_PARISC_PCREL64.  */
12484     case EM_PPC64:
12485       return reloc_type == 44; /* R_PPC64_REL64.  */
12486     case EM_SPARC32PLUS:
12487     case EM_SPARCV9:
12488     case EM_SPARC:
12489       return reloc_type == 46; /* R_SPARC_DISP64.  */
12490     case EM_X86_64:
12491     case EM_L1OM:
12492     case EM_K1OM:
12493       return reloc_type == 24; /* R_X86_64_PC64.  */
12494     case EM_S390_OLD:
12495     case EM_S390:
12496       return reloc_type == 23;  /* R_S390_PC64.  */
12497     case EM_TILEGX:
12498       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
12499     default:
12500       return FALSE;
12501     }
12502 }
12503
12504 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12505    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
12506
12507 static bfd_boolean
12508 is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12509 {
12510   switch (filedata->file_header.e_machine)
12511     {
12512     case EM_CYGNUS_MN10200:
12513     case EM_MN10200:
12514       return reloc_type == 4; /* R_MN10200_24.  */
12515     case EM_FT32:
12516       return reloc_type == 5; /* R_FT32_20.  */
12517     default:
12518       return FALSE;
12519     }
12520 }
12521
12522 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12523    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
12524
12525 static bfd_boolean
12526 is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12527 {
12528   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12529   switch (filedata->file_header.e_machine)
12530     {
12531     case EM_ARC:
12532     case EM_ARC_COMPACT:
12533     case EM_ARC_COMPACT2:
12534       return reloc_type == 2; /* R_ARC_16.  */
12535     case EM_ADAPTEVA_EPIPHANY:
12536       return reloc_type == 5;
12537     case EM_AVR_OLD:
12538     case EM_AVR:
12539       return reloc_type == 4; /* R_AVR_16.  */
12540     case EM_CYGNUS_D10V:
12541     case EM_D10V:
12542       return reloc_type == 3; /* R_D10V_16.  */
12543     case EM_FT32:
12544       return reloc_type == 2; /* R_FT32_16.  */
12545     case EM_H8S:
12546     case EM_H8_300:
12547     case EM_H8_300H:
12548       return reloc_type == R_H8_DIR16;
12549     case EM_IP2K_OLD:
12550     case EM_IP2K:
12551       return reloc_type == 1; /* R_IP2K_16.  */
12552     case EM_M32C_OLD:
12553     case EM_M32C:
12554       return reloc_type == 1; /* R_M32C_16 */
12555     case EM_CYGNUS_MN10200:
12556     case EM_MN10200:
12557       return reloc_type == 2; /* R_MN10200_16.  */
12558     case EM_CYGNUS_MN10300:
12559     case EM_MN10300:
12560       return reloc_type == 2; /* R_MN10300_16.  */
12561     case EM_MSP430:
12562       if (uses_msp430x_relocs (filedata))
12563         return reloc_type == 2; /* R_MSP430_ABS16.  */
12564       /* Fall through.  */
12565     case EM_MSP430_OLD:
12566       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
12567     case EM_NDS32:
12568       return reloc_type == 19; /* R_NDS32_RELA.  */
12569     case EM_ALTERA_NIOS2:
12570       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
12571     case EM_NIOS32:
12572       return reloc_type == 9; /* R_NIOS_16.  */
12573     case EM_OR1K:
12574       return reloc_type == 2; /* R_OR1K_16.  */
12575     case EM_TI_PRU:
12576       return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
12577     case EM_TI_C6000:
12578       return reloc_type == 2; /* R_C6000_ABS16.  */
12579     case EM_VISIUM:
12580       return reloc_type == 2; /* R_VISIUM_16. */
12581     case EM_XC16X:
12582     case EM_C166:
12583       return reloc_type == 2; /* R_XC16C_ABS_16.  */
12584     case EM_XGATE:
12585       return reloc_type == 3; /* R_XGATE_16.  */
12586     default:
12587       return FALSE;
12588     }
12589 }
12590
12591 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12592    a 32-bit inplace add RELA relocation used in DWARF debug sections.  */
12593
12594 static bfd_boolean
12595 is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12596 {
12597   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12598   switch (filedata->file_header.e_machine)
12599     {
12600     case EM_RISCV:
12601       return reloc_type == 35; /* R_RISCV_ADD32.  */
12602     default:
12603       return FALSE;
12604     }
12605 }
12606
12607 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12608    a 32-bit inplace sub RELA relocation used in DWARF debug sections.  */
12609
12610 static bfd_boolean
12611 is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12612 {
12613   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12614   switch (filedata->file_header.e_machine)
12615     {
12616     case EM_RISCV:
12617       return reloc_type == 39; /* R_RISCV_SUB32.  */
12618     default:
12619       return FALSE;
12620     }
12621 }
12622
12623 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12624    a 64-bit inplace add RELA relocation used in DWARF debug sections.  */
12625
12626 static bfd_boolean
12627 is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12628 {
12629   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12630   switch (filedata->file_header.e_machine)
12631     {
12632     case EM_RISCV:
12633       return reloc_type == 36; /* R_RISCV_ADD64.  */
12634     default:
12635       return FALSE;
12636     }
12637 }
12638
12639 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12640    a 64-bit inplace sub RELA relocation used in DWARF debug sections.  */
12641
12642 static bfd_boolean
12643 is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12644 {
12645   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12646   switch (filedata->file_header.e_machine)
12647     {
12648     case EM_RISCV:
12649       return reloc_type == 40; /* R_RISCV_SUB64.  */
12650     default:
12651       return FALSE;
12652     }
12653 }
12654
12655 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12656    a 16-bit inplace add RELA relocation used in DWARF debug sections.  */
12657
12658 static bfd_boolean
12659 is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12660 {
12661   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12662   switch (filedata->file_header.e_machine)
12663     {
12664     case EM_RISCV:
12665       return reloc_type == 34; /* R_RISCV_ADD16.  */
12666     default:
12667       return FALSE;
12668     }
12669 }
12670
12671 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12672    a 16-bit inplace sub RELA relocation used in DWARF debug sections.  */
12673
12674 static bfd_boolean
12675 is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12676 {
12677   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12678   switch (filedata->file_header.e_machine)
12679     {
12680     case EM_RISCV:
12681       return reloc_type == 38; /* R_RISCV_SUB16.  */
12682     default:
12683       return FALSE;
12684     }
12685 }
12686
12687 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12688    a 8-bit inplace add RELA relocation used in DWARF debug sections.  */
12689
12690 static bfd_boolean
12691 is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12692 {
12693   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12694   switch (filedata->file_header.e_machine)
12695     {
12696     case EM_RISCV:
12697       return reloc_type == 33; /* R_RISCV_ADD8.  */
12698     default:
12699       return FALSE;
12700     }
12701 }
12702
12703 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12704    a 8-bit inplace sub RELA relocation used in DWARF debug sections.  */
12705
12706 static bfd_boolean
12707 is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12708 {
12709   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12710   switch (filedata->file_header.e_machine)
12711     {
12712     case EM_RISCV:
12713       return reloc_type == 37; /* R_RISCV_SUB8.  */
12714     default:
12715       return FALSE;
12716     }
12717 }
12718
12719 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12720    relocation entries (possibly formerly used for SHT_GROUP sections).  */
12721
12722 static bfd_boolean
12723 is_none_reloc (Filedata * filedata, unsigned int reloc_type)
12724 {
12725   switch (filedata->file_header.e_machine)
12726     {
12727     case EM_386:     /* R_386_NONE.  */
12728     case EM_68K:     /* R_68K_NONE.  */
12729     case EM_ADAPTEVA_EPIPHANY:
12730     case EM_ALPHA:   /* R_ALPHA_NONE.  */
12731     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
12732     case EM_ARC:     /* R_ARC_NONE.  */
12733     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
12734     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
12735     case EM_ARM:     /* R_ARM_NONE.  */
12736     case EM_C166:    /* R_XC16X_NONE.  */
12737     case EM_CRIS:    /* R_CRIS_NONE.  */
12738     case EM_FT32:    /* R_FT32_NONE.  */
12739     case EM_IA_64:   /* R_IA64_NONE.  */
12740     case EM_K1OM:    /* R_X86_64_NONE.  */
12741     case EM_L1OM:    /* R_X86_64_NONE.  */
12742     case EM_M32R:    /* R_M32R_NONE.  */
12743     case EM_MIPS:    /* R_MIPS_NONE.  */
12744     case EM_MN10300: /* R_MN10300_NONE.  */
12745     case EM_MOXIE:   /* R_MOXIE_NONE.  */
12746     case EM_NIOS32:  /* R_NIOS_NONE.  */
12747     case EM_OR1K:    /* R_OR1K_NONE. */
12748     case EM_PARISC:  /* R_PARISC_NONE.  */
12749     case EM_PPC64:   /* R_PPC64_NONE.  */
12750     case EM_PPC:     /* R_PPC_NONE.  */
12751     case EM_RISCV:   /* R_RISCV_NONE.  */
12752     case EM_S390:    /* R_390_NONE.  */
12753     case EM_S390_OLD:
12754     case EM_SH:      /* R_SH_NONE.  */
12755     case EM_SPARC32PLUS:
12756     case EM_SPARC:   /* R_SPARC_NONE.  */
12757     case EM_SPARCV9:
12758     case EM_TILEGX:  /* R_TILEGX_NONE.  */
12759     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
12760     case EM_TI_C6000:/* R_C6000_NONE.  */
12761     case EM_X86_64:  /* R_X86_64_NONE.  */
12762     case EM_XC16X:
12763     case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
12764       return reloc_type == 0;
12765
12766     case EM_AARCH64:
12767       return reloc_type == 0 || reloc_type == 256;
12768     case EM_AVR_OLD:
12769     case EM_AVR:
12770       return (reloc_type == 0 /* R_AVR_NONE.  */
12771               || reloc_type == 30 /* R_AVR_DIFF8.  */
12772               || reloc_type == 31 /* R_AVR_DIFF16.  */
12773               || reloc_type == 32 /* R_AVR_DIFF32.  */);
12774     case EM_METAG:
12775       return reloc_type == 3; /* R_METAG_NONE.  */
12776     case EM_NDS32:
12777       return (reloc_type == 0       /* R_XTENSA_NONE.  */
12778               || reloc_type == 204  /* R_NDS32_DIFF8.  */
12779               || reloc_type == 205  /* R_NDS32_DIFF16.  */
12780               || reloc_type == 206  /* R_NDS32_DIFF32.  */
12781               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
12782     case EM_TI_PRU:
12783       return (reloc_type == 0       /* R_PRU_NONE.  */
12784               || reloc_type == 65   /* R_PRU_DIFF8.  */
12785               || reloc_type == 66   /* R_PRU_DIFF16.  */
12786               || reloc_type == 67   /* R_PRU_DIFF32.  */);
12787     case EM_XTENSA_OLD:
12788     case EM_XTENSA:
12789       return (reloc_type == 0      /* R_XTENSA_NONE.  */
12790               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
12791               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
12792               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
12793     }
12794   return FALSE;
12795 }
12796
12797 /* Returns TRUE if there is a relocation against
12798    section NAME at OFFSET bytes.  */
12799
12800 bfd_boolean
12801 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12802 {
12803   Elf_Internal_Rela * relocs;
12804   Elf_Internal_Rela * rp;
12805
12806   if (dsec == NULL || dsec->reloc_info == NULL)
12807     return FALSE;
12808
12809   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
12810
12811   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
12812     if (rp->r_offset == offset)
12813       return TRUE;
12814
12815    return FALSE;
12816 }
12817
12818 /* Apply relocations to a section.
12819    Returns TRUE upon success, FALSE otherwise.
12820    If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12821    It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
12822    will be set to the number of relocs loaded.
12823
12824    Note: So far support has been added only for those relocations
12825    which can be found in debug sections. FIXME: Add support for
12826    more relocations ?  */
12827
12828 static bfd_boolean
12829 apply_relocations (Filedata *                 filedata,
12830                    const Elf_Internal_Shdr *  section,
12831                    unsigned char *            start,
12832                    bfd_size_type              size,
12833                    void **                    relocs_return,
12834                    unsigned long *            num_relocs_return)
12835 {
12836   Elf_Internal_Shdr * relsec;
12837   unsigned char * end = start + size;
12838   bfd_boolean res = TRUE;
12839
12840   if (relocs_return != NULL)
12841     {
12842       * (Elf_Internal_Rela **) relocs_return = NULL;
12843       * num_relocs_return = 0;
12844     }
12845
12846   if (filedata->file_header.e_type != ET_REL)
12847     /* No relocs to apply.  */
12848     return TRUE;
12849
12850   /* Find the reloc section associated with the section.  */
12851   for (relsec = filedata->section_headers;
12852        relsec < filedata->section_headers + filedata->file_header.e_shnum;
12853        ++relsec)
12854     {
12855       bfd_boolean is_rela;
12856       unsigned long num_relocs;
12857       Elf_Internal_Rela * relocs;
12858       Elf_Internal_Rela * rp;
12859       Elf_Internal_Shdr * symsec;
12860       Elf_Internal_Sym * symtab;
12861       unsigned long num_syms;
12862       Elf_Internal_Sym * sym;
12863
12864       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12865           || relsec->sh_info >= filedata->file_header.e_shnum
12866           || filedata->section_headers + relsec->sh_info != section
12867           || relsec->sh_size == 0
12868           || relsec->sh_link >= filedata->file_header.e_shnum)
12869         continue;
12870
12871       is_rela = relsec->sh_type == SHT_RELA;
12872
12873       if (is_rela)
12874         {
12875           if (!slurp_rela_relocs (filedata, relsec->sh_offset,
12876                                   relsec->sh_size, & relocs, & num_relocs))
12877             return FALSE;
12878         }
12879       else
12880         {
12881           if (!slurp_rel_relocs (filedata, relsec->sh_offset,
12882                                  relsec->sh_size, & relocs, & num_relocs))
12883             return FALSE;
12884         }
12885
12886       /* SH uses RELA but uses in place value instead of the addend field.  */
12887       if (filedata->file_header.e_machine == EM_SH)
12888         is_rela = FALSE;
12889
12890       symsec = filedata->section_headers + relsec->sh_link;
12891       if (symsec->sh_type != SHT_SYMTAB
12892           && symsec->sh_type != SHT_DYNSYM)
12893         return FALSE;
12894       symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
12895
12896       for (rp = relocs; rp < relocs + num_relocs; ++rp)
12897         {
12898           bfd_vma         addend;
12899           unsigned int    reloc_type;
12900           unsigned int    reloc_size;
12901           bfd_boolean     reloc_inplace = FALSE;
12902           bfd_boolean     reloc_subtract = FALSE;
12903           unsigned char * rloc;
12904           unsigned long   sym_index;
12905
12906           reloc_type = get_reloc_type (filedata, rp->r_info);
12907
12908           if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
12909             continue;
12910           else if (is_none_reloc (filedata, reloc_type))
12911             continue;
12912           else if (is_32bit_abs_reloc (filedata, reloc_type)
12913                    || is_32bit_pcrel_reloc (filedata, reloc_type))
12914             reloc_size = 4;
12915           else if (is_64bit_abs_reloc (filedata, reloc_type)
12916                    || is_64bit_pcrel_reloc (filedata, reloc_type))
12917             reloc_size = 8;
12918           else if (is_24bit_abs_reloc (filedata, reloc_type))
12919             reloc_size = 3;
12920           else if (is_16bit_abs_reloc (filedata, reloc_type))
12921             reloc_size = 2;
12922           else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
12923                                                                  reloc_type))
12924                    || is_32bit_inplace_add_reloc (filedata, reloc_type))
12925             {
12926               reloc_size = 4;
12927               reloc_inplace = TRUE;
12928             }
12929           else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
12930                                                                  reloc_type))
12931                    || is_64bit_inplace_add_reloc (filedata, reloc_type))
12932             {
12933               reloc_size = 8;
12934               reloc_inplace = TRUE;
12935             }
12936           else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
12937                                                                  reloc_type))
12938                    || is_16bit_inplace_add_reloc (filedata, reloc_type))
12939             {
12940               reloc_size = 2;
12941               reloc_inplace = TRUE;
12942             }
12943           else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
12944                                                                 reloc_type))
12945                    || is_8bit_inplace_add_reloc (filedata, reloc_type))
12946             {
12947               reloc_size = 1;
12948               reloc_inplace = TRUE;
12949             }
12950           else
12951             {
12952               static unsigned int prev_reloc = 0;
12953
12954               if (reloc_type != prev_reloc)
12955                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12956                       reloc_type, printable_section_name (filedata, section));
12957               prev_reloc = reloc_type;
12958               res = FALSE;
12959               continue;
12960             }
12961
12962           rloc = start + rp->r_offset;
12963           if ((rloc + reloc_size) > end || (rloc < start))
12964             {
12965               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12966                     (unsigned long) rp->r_offset,
12967                     printable_section_name (filedata, section));
12968               res = FALSE;
12969               continue;
12970             }
12971
12972           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
12973           if (sym_index >= num_syms)
12974             {
12975               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12976                     sym_index, printable_section_name (filedata, section));
12977               res = FALSE;
12978               continue;
12979             }
12980           sym = symtab + sym_index;
12981
12982           /* If the reloc has a symbol associated with it,
12983              make sure that it is of an appropriate type.
12984
12985              Relocations against symbols without type can happen.
12986              Gcc -feliminate-dwarf2-dups may generate symbols
12987              without type for debug info.
12988
12989              Icc generates relocations against function symbols
12990              instead of local labels.
12991
12992              Relocations against object symbols can happen, eg when
12993              referencing a global array.  For an example of this see
12994              the _clz.o binary in libgcc.a.  */
12995           if (sym != symtab
12996               && ELF_ST_TYPE (sym->st_info) != STT_COMMON
12997               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
12998             {
12999               warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13000                     get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13001                     printable_section_name (filedata, relsec),
13002                     (long int)(rp - relocs));
13003               res = FALSE;
13004               continue;
13005             }
13006
13007           addend = 0;
13008           if (is_rela)
13009             addend += rp->r_addend;
13010           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13011              partial_inplace.  */
13012           if (!is_rela
13013               || (filedata->file_header.e_machine == EM_XTENSA
13014                   && reloc_type == 1)
13015               || ((filedata->file_header.e_machine == EM_PJ
13016                    || filedata->file_header.e_machine == EM_PJ_OLD)
13017                   && reloc_type == 1)
13018               || ((filedata->file_header.e_machine == EM_D30V
13019                    || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13020                   && reloc_type == 12)
13021               || reloc_inplace)
13022             addend += byte_get (rloc, reloc_size);
13023
13024           if (is_32bit_pcrel_reloc (filedata, reloc_type)
13025               || is_64bit_pcrel_reloc (filedata, reloc_type))
13026             {
13027               /* On HPPA, all pc-relative relocations are biased by 8.  */
13028               if (filedata->file_header.e_machine == EM_PARISC)
13029                 addend -= 8;
13030               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13031                         reloc_size);
13032             }
13033           else if (reloc_subtract)
13034             byte_put (rloc, addend - sym->st_value, reloc_size);
13035           else
13036             byte_put (rloc, addend + sym->st_value, reloc_size);
13037         }
13038
13039       free (symtab);
13040       /* Let the target specific reloc processing code know that
13041          we have finished with these relocs.  */
13042       target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13043
13044       if (relocs_return)
13045         {
13046           * (Elf_Internal_Rela **) relocs_return = relocs;
13047           * num_relocs_return = num_relocs;
13048         }
13049       else
13050         free (relocs);
13051
13052       break;
13053     }
13054
13055   return res;
13056 }
13057
13058 #ifdef SUPPORT_DISASSEMBLY
13059 static bfd_boolean
13060 disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13061 {
13062   printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13063
13064   /* FIXME: XXX -- to be done --- XXX */
13065
13066   return TRUE;
13067 }
13068 #endif
13069
13070 /* Reads in the contents of SECTION from FILE, returning a pointer
13071    to a malloc'ed buffer or NULL if something went wrong.  */
13072
13073 static char *
13074 get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13075 {
13076   bfd_size_type num_bytes = section->sh_size;
13077
13078   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13079     {
13080       printf (_("Section '%s' has no data to dump.\n"),
13081               printable_section_name (filedata, section));
13082       return NULL;
13083     }
13084
13085   return  (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13086                              _("section contents"));
13087 }
13088
13089 /* Uncompresses a section that was compressed using zlib, in place.  */
13090
13091 static bfd_boolean
13092 uncompress_section_contents (unsigned char **   buffer,
13093                              dwarf_size_type    uncompressed_size,
13094                              dwarf_size_type *  size)
13095 {
13096   dwarf_size_type compressed_size = *size;
13097   unsigned char * compressed_buffer = *buffer;
13098   unsigned char * uncompressed_buffer;
13099   z_stream strm;
13100   int rc;
13101
13102   /* It is possible the section consists of several compressed
13103      buffers concatenated together, so we uncompress in a loop.  */
13104   /* PR 18313: The state field in the z_stream structure is supposed
13105      to be invisible to the user (ie us), but some compilers will
13106      still complain about it being used without initialisation.  So
13107      we first zero the entire z_stream structure and then set the fields
13108      that we need.  */
13109   memset (& strm, 0, sizeof strm);
13110   strm.avail_in = compressed_size;
13111   strm.next_in = (Bytef *) compressed_buffer;
13112   strm.avail_out = uncompressed_size;
13113   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13114
13115   rc = inflateInit (& strm);
13116   while (strm.avail_in > 0)
13117     {
13118       if (rc != Z_OK)
13119         goto fail;
13120       strm.next_out = ((Bytef *) uncompressed_buffer
13121                        + (uncompressed_size - strm.avail_out));
13122       rc = inflate (&strm, Z_FINISH);
13123       if (rc != Z_STREAM_END)
13124         goto fail;
13125       rc = inflateReset (& strm);
13126     }
13127   rc = inflateEnd (& strm);
13128   if (rc != Z_OK
13129       || strm.avail_out != 0)
13130     goto fail;
13131
13132   *buffer = uncompressed_buffer;
13133   *size = uncompressed_size;
13134   return TRUE;
13135
13136  fail:
13137   free (uncompressed_buffer);
13138   /* Indicate decompression failure.  */
13139   *buffer = NULL;
13140   return FALSE;
13141 }
13142
13143 static bfd_boolean
13144 dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13145 {
13146   Elf_Internal_Shdr *  relsec;
13147   bfd_size_type        num_bytes;
13148   unsigned char *      data;
13149   unsigned char *      end;
13150   unsigned char *      real_start;
13151   unsigned char *      start;
13152   bfd_boolean          some_strings_shown;
13153
13154   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13155   if (start == NULL)
13156     /* PR 21820: Do not fail if the section was empty.  */
13157     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13158
13159   num_bytes = section->sh_size;
13160
13161   printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13162
13163   if (decompress_dumps)
13164     {
13165       dwarf_size_type new_size = num_bytes;
13166       dwarf_size_type uncompressed_size = 0;
13167
13168       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13169         {
13170           Elf_Internal_Chdr chdr;
13171           unsigned int compression_header_size
13172             = get_compression_header (& chdr, (unsigned char *) start,
13173                                       num_bytes);
13174
13175           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13176             {
13177               warn (_("section '%s' has unsupported compress type: %d\n"),
13178                     printable_section_name (filedata, section), chdr.ch_type);
13179               return FALSE;
13180             }
13181           else if (chdr.ch_addralign != section->sh_addralign)
13182             {
13183               warn (_("compressed section '%s' is corrupted\n"),
13184                     printable_section_name (filedata, section));
13185               return FALSE;
13186             }
13187           uncompressed_size = chdr.ch_size;
13188           start += compression_header_size;
13189           new_size -= compression_header_size;
13190         }
13191       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13192         {
13193           /* Read the zlib header.  In this case, it should be "ZLIB"
13194              followed by the uncompressed section size, 8 bytes in
13195              big-endian order.  */
13196           uncompressed_size = start[4]; uncompressed_size <<= 8;
13197           uncompressed_size += start[5]; uncompressed_size <<= 8;
13198           uncompressed_size += start[6]; uncompressed_size <<= 8;
13199           uncompressed_size += start[7]; uncompressed_size <<= 8;
13200           uncompressed_size += start[8]; uncompressed_size <<= 8;
13201           uncompressed_size += start[9]; uncompressed_size <<= 8;
13202           uncompressed_size += start[10]; uncompressed_size <<= 8;
13203           uncompressed_size += start[11];
13204           start += 12;
13205           new_size -= 12;
13206         }
13207
13208       if (uncompressed_size)
13209         {
13210           if (uncompress_section_contents (& start,
13211                                            uncompressed_size, & new_size))
13212             num_bytes = new_size;
13213           else
13214             {
13215               error (_("Unable to decompress section %s\n"),
13216                      printable_section_name (filedata, section));
13217               return FALSE;
13218             }
13219         }
13220       else
13221         start = real_start;
13222     }
13223
13224   /* If the section being dumped has relocations against it the user might
13225      be expecting these relocations to have been applied.  Check for this
13226      case and issue a warning message in order to avoid confusion.
13227      FIXME: Maybe we ought to have an option that dumps a section with
13228      relocs applied ?  */
13229   for (relsec = filedata->section_headers;
13230        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13231        ++relsec)
13232     {
13233       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13234           || relsec->sh_info >= filedata->file_header.e_shnum
13235           || filedata->section_headers + relsec->sh_info != section
13236           || relsec->sh_size == 0
13237           || relsec->sh_link >= filedata->file_header.e_shnum)
13238         continue;
13239
13240       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13241       break;
13242     }
13243
13244   data = start;
13245   end  = start + num_bytes;
13246   some_strings_shown = FALSE;
13247
13248   while (data < end)
13249     {
13250       while (!ISPRINT (* data))
13251         if (++ data >= end)
13252           break;
13253
13254       if (data < end)
13255         {
13256           size_t maxlen = end - data;
13257
13258 #ifndef __MSVCRT__
13259           /* PR 11128: Use two separate invocations in order to work
13260              around bugs in the Solaris 8 implementation of printf.  */
13261           printf ("  [%6tx]  ", data - start);
13262 #else
13263           printf ("  [%6Ix]  ", (size_t) (data - start));
13264 #endif
13265           if (maxlen > 0)
13266             {
13267               print_symbol ((int) maxlen, (const char *) data);
13268               putchar ('\n');
13269               data += strnlen ((const char *) data, maxlen);
13270             }
13271           else
13272             {
13273               printf (_("<corrupt>\n"));
13274               data = end;
13275             }
13276           some_strings_shown = TRUE;
13277         }
13278     }
13279
13280   if (! some_strings_shown)
13281     printf (_("  No strings found in this section."));
13282
13283   free (real_start);
13284
13285   putchar ('\n');
13286   return TRUE;
13287 }
13288
13289 static bfd_boolean
13290 dump_section_as_bytes (Elf_Internal_Shdr *  section,
13291                        Filedata *           filedata,
13292                        bfd_boolean          relocate)
13293 {
13294   Elf_Internal_Shdr * relsec;
13295   bfd_size_type       bytes;
13296   bfd_size_type       section_size;
13297   bfd_vma             addr;
13298   unsigned char *     data;
13299   unsigned char *     real_start;
13300   unsigned char *     start;
13301
13302   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13303   if (start == NULL)
13304     /* PR 21820: Do not fail if the section was empty.  */
13305     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13306
13307   section_size = section->sh_size;
13308
13309   printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13310
13311   if (decompress_dumps)
13312     {
13313       dwarf_size_type new_size = section_size;
13314       dwarf_size_type uncompressed_size = 0;
13315
13316       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13317         {
13318           Elf_Internal_Chdr chdr;
13319           unsigned int compression_header_size
13320             = get_compression_header (& chdr, start, section_size);
13321
13322           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13323             {
13324               warn (_("section '%s' has unsupported compress type: %d\n"),
13325                     printable_section_name (filedata, section), chdr.ch_type);
13326               return FALSE;
13327             }
13328           else if (chdr.ch_addralign != section->sh_addralign)
13329             {
13330               warn (_("compressed section '%s' is corrupted\n"),
13331                     printable_section_name (filedata, section));
13332               return FALSE;
13333             }
13334           uncompressed_size = chdr.ch_size;
13335           start += compression_header_size;
13336           new_size -= compression_header_size;
13337         }
13338       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13339         {
13340           /* Read the zlib header.  In this case, it should be "ZLIB"
13341              followed by the uncompressed section size, 8 bytes in
13342              big-endian order.  */
13343           uncompressed_size = start[4]; uncompressed_size <<= 8;
13344           uncompressed_size += start[5]; uncompressed_size <<= 8;
13345           uncompressed_size += start[6]; uncompressed_size <<= 8;
13346           uncompressed_size += start[7]; uncompressed_size <<= 8;
13347           uncompressed_size += start[8]; uncompressed_size <<= 8;
13348           uncompressed_size += start[9]; uncompressed_size <<= 8;
13349           uncompressed_size += start[10]; uncompressed_size <<= 8;
13350           uncompressed_size += start[11];
13351           start += 12;
13352           new_size -= 12;
13353         }
13354
13355       if (uncompressed_size)
13356         {
13357           if (uncompress_section_contents (& start, uncompressed_size,
13358                                            & new_size))
13359             {
13360               section_size = new_size;
13361             }
13362           else
13363             {
13364               error (_("Unable to decompress section %s\n"),
13365                      printable_section_name (filedata, section));
13366               /* FIXME: Print the section anyway ?  */
13367               return FALSE;
13368             }
13369         }
13370       else
13371         start = real_start;
13372     }
13373
13374   if (relocate)
13375     {
13376       if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
13377         return FALSE;
13378     }
13379   else
13380     {
13381       /* If the section being dumped has relocations against it the user might
13382          be expecting these relocations to have been applied.  Check for this
13383          case and issue a warning message in order to avoid confusion.
13384          FIXME: Maybe we ought to have an option that dumps a section with
13385          relocs applied ?  */
13386       for (relsec = filedata->section_headers;
13387            relsec < filedata->section_headers + filedata->file_header.e_shnum;
13388            ++relsec)
13389         {
13390           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13391               || relsec->sh_info >= filedata->file_header.e_shnum
13392               || filedata->section_headers + relsec->sh_info != section
13393               || relsec->sh_size == 0
13394               || relsec->sh_link >= filedata->file_header.e_shnum)
13395             continue;
13396
13397           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13398           break;
13399         }
13400     }
13401
13402   addr = section->sh_addr;
13403   bytes = section_size;
13404   data = start;
13405
13406   while (bytes)
13407     {
13408       int j;
13409       int k;
13410       int lbytes;
13411
13412       lbytes = (bytes > 16 ? 16 : bytes);
13413
13414       printf ("  0x%8.8lx ", (unsigned long) addr);
13415
13416       for (j = 0; j < 16; j++)
13417         {
13418           if (j < lbytes)
13419             printf ("%2.2x", data[j]);
13420           else
13421             printf ("  ");
13422
13423           if ((j & 3) == 3)
13424             printf (" ");
13425         }
13426
13427       for (j = 0; j < lbytes; j++)
13428         {
13429           k = data[j];
13430           if (k >= ' ' && k < 0x7f)
13431             printf ("%c", k);
13432           else
13433             printf (".");
13434         }
13435
13436       putchar ('\n');
13437
13438       data  += lbytes;
13439       addr  += lbytes;
13440       bytes -= lbytes;
13441     }
13442
13443   free (real_start);
13444
13445   putchar ('\n');
13446   return TRUE;
13447 }
13448
13449 static bfd_boolean
13450 load_specific_debug_section (enum dwarf_section_display_enum  debug,
13451                              const Elf_Internal_Shdr *        sec,
13452                              void *                           data)
13453 {
13454   struct dwarf_section * section = &debug_displays [debug].section;
13455   char buf [64];
13456   Filedata * filedata = (Filedata *) data;
13457
13458   if (section->start != NULL)
13459     {
13460       /* If it is already loaded, do nothing.  */
13461       if (streq (section->filename, filedata->file_name))
13462         return TRUE;
13463       free (section->start);
13464     }
13465
13466   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13467   section->address = sec->sh_addr;
13468   section->user_data = NULL;
13469   section->filename = filedata->file_name;
13470   section->start = (unsigned char *) get_data (NULL, filedata,
13471                                                sec->sh_offset, 1,
13472                                                sec->sh_size, buf);
13473   if (section->start == NULL)
13474     section->size = 0;
13475   else
13476     {
13477       unsigned char *start = section->start;
13478       dwarf_size_type size = sec->sh_size;
13479       dwarf_size_type uncompressed_size = 0;
13480
13481       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13482         {
13483           Elf_Internal_Chdr chdr;
13484           unsigned int compression_header_size;
13485
13486           if (size < (is_32bit_elf
13487                       ? sizeof (Elf32_External_Chdr)
13488                       : sizeof (Elf64_External_Chdr)))
13489             {
13490               warn (_("compressed section %s is too small to contain a compression header"),
13491                     section->name);
13492               return FALSE;
13493             }
13494
13495           compression_header_size = get_compression_header (&chdr, start, size);
13496
13497           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13498             {
13499               warn (_("section '%s' has unsupported compress type: %d\n"),
13500                     section->name, chdr.ch_type);
13501               return FALSE;
13502             }
13503           else if (chdr.ch_addralign != sec->sh_addralign)
13504             {
13505               warn (_("compressed section '%s' is corrupted\n"),
13506                     section->name);
13507               return FALSE;
13508             }
13509           uncompressed_size = chdr.ch_size;
13510           start += compression_header_size;
13511           size -= compression_header_size;
13512         }
13513       else if (size > 12 && streq ((char *) start, "ZLIB"))
13514         {
13515           /* Read the zlib header.  In this case, it should be "ZLIB"
13516              followed by the uncompressed section size, 8 bytes in
13517              big-endian order.  */
13518           uncompressed_size = start[4]; uncompressed_size <<= 8;
13519           uncompressed_size += start[5]; uncompressed_size <<= 8;
13520           uncompressed_size += start[6]; uncompressed_size <<= 8;
13521           uncompressed_size += start[7]; uncompressed_size <<= 8;
13522           uncompressed_size += start[8]; uncompressed_size <<= 8;
13523           uncompressed_size += start[9]; uncompressed_size <<= 8;
13524           uncompressed_size += start[10]; uncompressed_size <<= 8;
13525           uncompressed_size += start[11];
13526           start += 12;
13527           size -= 12;
13528         }
13529
13530       if (uncompressed_size)
13531         {
13532           if (uncompress_section_contents (&start, uncompressed_size,
13533                                            &size))
13534             {
13535               /* Free the compressed buffer, update the section buffer
13536                  and the section size if uncompress is successful.  */
13537               free (section->start);
13538               section->start = start;
13539             }
13540           else
13541             {
13542               error (_("Unable to decompress section %s\n"),
13543                      printable_section_name (filedata, sec));
13544               return FALSE;
13545             }
13546         }
13547
13548       section->size = size;
13549     }
13550
13551   if (section->start == NULL)
13552     return FALSE;
13553
13554   if (debug_displays [debug].relocate)
13555     {
13556       if (! apply_relocations (filedata, sec, section->start, section->size,
13557                                & section->reloc_info, & section->num_relocs))
13558         return FALSE;
13559     }
13560   else
13561     {
13562       section->reloc_info = NULL;
13563       section->num_relocs = 0;
13564     }
13565
13566   return TRUE;
13567 }
13568
13569 /* If this is not NULL, load_debug_section will only look for sections
13570    within the list of sections given here.  */
13571 static unsigned int * section_subset = NULL;
13572
13573 bfd_boolean
13574 load_debug_section (enum dwarf_section_display_enum debug, void * data)
13575 {
13576   struct dwarf_section * section = &debug_displays [debug].section;
13577   Elf_Internal_Shdr * sec;
13578   Filedata * filedata = (Filedata *) data;
13579
13580   /* Without section headers we cannot find any sections.  */
13581   if (filedata->section_headers == NULL)
13582     return FALSE;
13583
13584   if (filedata->string_table == NULL
13585       && filedata->file_header.e_shstrndx != SHN_UNDEF
13586       && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
13587     {
13588       Elf_Internal_Shdr * strs;
13589
13590       /* Read in the string table, so that we have section names to scan.  */
13591       strs = filedata->section_headers + filedata->file_header.e_shstrndx;
13592
13593       if (strs != NULL && strs->sh_size != 0)
13594         {
13595           filedata->string_table
13596             = (char *) get_data (NULL, filedata, strs->sh_offset,
13597                                  1, strs->sh_size, _("string table"));
13598
13599           filedata->string_table_length
13600             = filedata->string_table != NULL ? strs->sh_size : 0;
13601         }
13602     }
13603
13604   /* Locate the debug section.  */
13605   sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
13606   if (sec != NULL)
13607     section->name = section->uncompressed_name;
13608   else
13609     {
13610       sec = find_section_in_set (filedata, section->compressed_name, section_subset);
13611       if (sec != NULL)
13612         section->name = section->compressed_name;
13613     }
13614   if (sec == NULL)
13615     return FALSE;
13616
13617   /* If we're loading from a subset of sections, and we've loaded
13618      a section matching this name before, it's likely that it's a
13619      different one.  */
13620   if (section_subset != NULL)
13621     free_debug_section (debug);
13622
13623   return load_specific_debug_section (debug, sec, data);
13624 }
13625
13626 void
13627 free_debug_section (enum dwarf_section_display_enum debug)
13628 {
13629   struct dwarf_section * section = &debug_displays [debug].section;
13630
13631   if (section->start == NULL)
13632     return;
13633
13634   free ((char *) section->start);
13635   section->start = NULL;
13636   section->address = 0;
13637   section->size = 0;
13638 }
13639
13640 static bfd_boolean
13641 display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
13642 {
13643   char * name = SECTION_NAME (section);
13644   const char * print_name = printable_section_name (filedata, section);
13645   bfd_size_type length;
13646   bfd_boolean result = TRUE;
13647   int i;
13648
13649   length = section->sh_size;
13650   if (length == 0)
13651     {
13652       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13653       return TRUE;
13654     }
13655   if (section->sh_type == SHT_NOBITS)
13656     {
13657       /* There is no point in dumping the contents of a debugging section
13658          which has the NOBITS type - the bits in the file will be random.
13659          This can happen when a file containing a .eh_frame section is
13660          stripped with the --only-keep-debug command line option.  */
13661       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13662               print_name);
13663       return FALSE;
13664     }
13665
13666   if (const_strneq (name, ".gnu.linkonce.wi."))
13667     name = ".debug_info";
13668
13669   /* See if we know how to display the contents of this section.  */
13670   for (i = 0; i < max; i++)
13671     {
13672       enum dwarf_section_display_enum  id = (enum dwarf_section_display_enum) i;
13673       struct dwarf_section_display *   display = debug_displays + i;
13674       struct dwarf_section *           sec = & display->section;
13675
13676       if (streq (sec->uncompressed_name, name)
13677           || (id == line && const_strneq (name, ".debug_line."))
13678           || streq (sec->compressed_name, name))
13679         {
13680           bfd_boolean secondary = (section != find_section (filedata, name));
13681
13682           if (secondary)
13683             free_debug_section (id);
13684
13685           if (i == line && const_strneq (name, ".debug_line."))
13686             sec->name = name;
13687           else if (streq (sec->uncompressed_name, name))
13688             sec->name = sec->uncompressed_name;
13689           else
13690             sec->name = sec->compressed_name;
13691
13692           if (load_specific_debug_section (id, section, filedata))
13693             {
13694               /* If this debug section is part of a CU/TU set in a .dwp file,
13695                  restrict load_debug_section to the sections in that set.  */
13696               section_subset = find_cu_tu_set (filedata, shndx);
13697
13698               result &= display->display (sec, filedata);
13699
13700               section_subset = NULL;
13701
13702               if (secondary || (id != info && id != abbrev))
13703                 free_debug_section (id);
13704             }
13705           break;
13706         }
13707     }
13708
13709   if (i == max)
13710     {
13711       printf (_("Unrecognized debug section: %s\n"), print_name);
13712       result = FALSE;
13713     }
13714
13715   return result;
13716 }
13717
13718 /* Set DUMP_SECTS for all sections where dumps were requested
13719    based on section name.  */
13720
13721 static void
13722 initialise_dumps_byname (Filedata * filedata)
13723 {
13724   struct dump_list_entry * cur;
13725
13726   for (cur = dump_sects_byname; cur; cur = cur->next)
13727     {
13728       unsigned int i;
13729       bfd_boolean any = FALSE;
13730
13731       for (i = 0; i < filedata->file_header.e_shnum; i++)
13732         if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
13733           {
13734             request_dump_bynumber (filedata, i, cur->type);
13735             any = TRUE;
13736           }
13737
13738       if (!any)
13739         warn (_("Section '%s' was not dumped because it does not exist!\n"),
13740               cur->name);
13741     }
13742 }
13743
13744 static bfd_boolean
13745 process_section_contents (Filedata * filedata)
13746 {
13747   Elf_Internal_Shdr * section;
13748   unsigned int i;
13749   bfd_boolean res = TRUE;
13750
13751   if (! do_dump)
13752     return TRUE;
13753
13754   initialise_dumps_byname (filedata);
13755
13756   for (i = 0, section = filedata->section_headers;
13757        i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
13758        i++, section++)
13759     {
13760       dump_type dump = filedata->dump_sects[i];
13761
13762 #ifdef SUPPORT_DISASSEMBLY
13763       if (dump & DISASS_DUMP)
13764         {
13765           if (! disassemble_section (section, filedata))
13766             res = FALSE;
13767         }
13768 #endif
13769       if (dump & HEX_DUMP)
13770         {
13771           if (! dump_section_as_bytes (section, filedata, FALSE))
13772             res = FALSE;
13773         }
13774
13775       if (dump & RELOC_DUMP)
13776         {
13777           if (! dump_section_as_bytes (section, filedata, TRUE))
13778             res = FALSE;
13779         }
13780
13781       if (dump & STRING_DUMP)
13782         {
13783           if (! dump_section_as_strings (section, filedata))
13784             res = FALSE;
13785         }
13786
13787       if (dump & DEBUG_DUMP)
13788         {
13789           if (! display_debug_section (i, section, filedata))
13790             res = FALSE;
13791         }
13792     }
13793
13794   /* Check to see if the user requested a
13795      dump of a section that does not exist.  */
13796   while (i < filedata->num_dump_sects)
13797     {
13798       if (filedata->dump_sects[i])
13799         {
13800           warn (_("Section %d was not dumped because it does not exist!\n"), i);
13801           res = FALSE;
13802         }
13803       i++;
13804     }
13805
13806   return res;
13807 }
13808
13809 static void
13810 process_mips_fpe_exception (int mask)
13811 {
13812   if (mask)
13813     {
13814       bfd_boolean first = TRUE;
13815
13816       if (mask & OEX_FPU_INEX)
13817         fputs ("INEX", stdout), first = FALSE;
13818       if (mask & OEX_FPU_UFLO)
13819         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
13820       if (mask & OEX_FPU_OFLO)
13821         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
13822       if (mask & OEX_FPU_DIV0)
13823         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
13824       if (mask & OEX_FPU_INVAL)
13825         printf ("%sINVAL", first ? "" : "|");
13826     }
13827   else
13828     fputs ("0", stdout);
13829 }
13830
13831 /* Display's the value of TAG at location P.  If TAG is
13832    greater than 0 it is assumed to be an unknown tag, and
13833    a message is printed to this effect.  Otherwise it is
13834    assumed that a message has already been printed.
13835
13836    If the bottom bit of TAG is set it assumed to have a
13837    string value, otherwise it is assumed to have an integer
13838    value.
13839
13840    Returns an updated P pointing to the first unread byte
13841    beyond the end of TAG's value.
13842
13843    Reads at or beyond END will not be made.  */
13844
13845 static unsigned char *
13846 display_tag_value (signed int tag,
13847                    unsigned char * p,
13848                    const unsigned char * const end)
13849 {
13850   unsigned long val;
13851
13852   if (tag > 0)
13853     printf ("  Tag_unknown_%d: ", tag);
13854
13855   if (p >= end)
13856     {
13857       warn (_("<corrupt tag>\n"));
13858     }
13859   else if (tag & 1)
13860     {
13861       /* PR 17531 file: 027-19978-0.004.  */
13862       size_t maxlen = (end - p) - 1;
13863
13864       putchar ('"');
13865       if (maxlen > 0)
13866         {
13867           print_symbol ((int) maxlen, (const char *) p);
13868           p += strnlen ((char *) p, maxlen) + 1;
13869         }
13870       else
13871         {
13872           printf (_("<corrupt string tag>"));
13873           p = (unsigned char *) end;
13874         }
13875       printf ("\"\n");
13876     }
13877   else
13878     {
13879       unsigned int len;
13880
13881       val = read_uleb128 (p, &len, end);
13882       p += len;
13883       printf ("%ld (0x%lx)\n", val, val);
13884     }
13885
13886   assert (p <= end);
13887   return p;
13888 }
13889
13890 /* ARC ABI attributes section.  */
13891
13892 static unsigned char *
13893 display_arc_attribute (unsigned char * p,
13894                        const unsigned char * const end)
13895 {
13896   unsigned int tag;
13897   unsigned int len;
13898   unsigned int val;
13899
13900   tag = read_uleb128 (p, &len, end);
13901   p += len;
13902
13903   switch (tag)
13904     {
13905     case Tag_ARC_PCS_config:
13906       val = read_uleb128 (p, &len, end);
13907       p += len;
13908       printf ("  Tag_ARC_PCS_config: ");
13909       switch (val)
13910         {
13911         case 0:
13912           printf (_("Absent/Non standard\n"));
13913           break;
13914         case 1:
13915           printf (_("Bare metal/mwdt\n"));
13916           break;
13917         case 2:
13918           printf (_("Bare metal/newlib\n"));
13919           break;
13920         case 3:
13921           printf (_("Linux/uclibc\n"));
13922           break;
13923         case 4:
13924           printf (_("Linux/glibc\n"));
13925           break;
13926         default:
13927           printf (_("Unknown\n"));
13928           break;
13929         }
13930       break;
13931
13932     case Tag_ARC_CPU_base:
13933       val = read_uleb128 (p, &len, end);
13934       p += len;
13935       printf ("  Tag_ARC_CPU_base: ");
13936       switch (val)
13937         {
13938         default:
13939         case TAG_CPU_NONE:
13940           printf (_("Absent\n"));
13941           break;
13942         case TAG_CPU_ARC6xx:
13943           printf ("ARC6xx\n");
13944           break;
13945         case TAG_CPU_ARC7xx:
13946           printf ("ARC7xx\n");
13947           break;
13948         case TAG_CPU_ARCEM:
13949           printf ("ARCEM\n");
13950           break;
13951         case TAG_CPU_ARCHS:
13952           printf ("ARCHS\n");
13953           break;
13954         }
13955       break;
13956
13957     case Tag_ARC_CPU_variation:
13958       val = read_uleb128 (p, &len, end);
13959       p += len;
13960       printf ("  Tag_ARC_CPU_variation: ");
13961       switch (val)
13962         {
13963         default:
13964           if (val > 0 && val < 16)
13965               printf ("Core%d\n", val);
13966           else
13967               printf ("Unknown\n");
13968           break;
13969
13970         case 0:
13971           printf (_("Absent\n"));
13972           break;
13973         }
13974       break;
13975
13976     case Tag_ARC_CPU_name:
13977       printf ("  Tag_ARC_CPU_name: ");
13978       p = display_tag_value (-1, p, end);
13979       break;
13980
13981     case Tag_ARC_ABI_rf16:
13982       val = read_uleb128 (p, &len, end);
13983       p += len;
13984       printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
13985       break;
13986
13987     case Tag_ARC_ABI_osver:
13988       val = read_uleb128 (p, &len, end);
13989       p += len;
13990       printf ("  Tag_ARC_ABI_osver: v%d\n", val);
13991       break;
13992
13993     case Tag_ARC_ABI_pic:
13994     case Tag_ARC_ABI_sda:
13995       val = read_uleb128 (p, &len, end);
13996       p += len;
13997       printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
13998               : "  Tag_ARC_ABI_pic: ");
13999       switch (val)
14000         {
14001         case 0:
14002           printf (_("Absent\n"));
14003           break;
14004         case 1:
14005           printf ("MWDT\n");
14006           break;
14007         case 2:
14008           printf ("GNU\n");
14009           break;
14010         default:
14011           printf (_("Unknown\n"));
14012           break;
14013         }
14014       break;
14015
14016     case Tag_ARC_ABI_tls:
14017       val = read_uleb128 (p, &len, end);
14018       p += len;
14019       printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14020       break;
14021
14022     case Tag_ARC_ABI_enumsize:
14023       val = read_uleb128 (p, &len, end);
14024       p += len;
14025       printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14026               _("smallest"));
14027       break;
14028
14029     case Tag_ARC_ABI_exceptions:
14030       val = read_uleb128 (p, &len, end);
14031       p += len;
14032       printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14033               : _("default"));
14034       break;
14035
14036     case Tag_ARC_ABI_double_size:
14037       val = read_uleb128 (p, &len, end);
14038       p += len;
14039       printf ("  Tag_ARC_ABI_double_size: %d\n", val);
14040       break;
14041
14042     case Tag_ARC_ISA_config:
14043       printf ("  Tag_ARC_ISA_config: ");
14044       p = display_tag_value (-1, p, end);
14045       break;
14046
14047     case Tag_ARC_ISA_apex:
14048       printf ("  Tag_ARC_ISA_apex: ");
14049       p = display_tag_value (-1, p, end);
14050       break;
14051
14052     case Tag_ARC_ISA_mpy_option:
14053       val = read_uleb128 (p, &len, end);
14054       p += len;
14055       printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
14056       break;
14057
14058     default:
14059       return display_tag_value (tag & 1, p, end);
14060     }
14061
14062   return p;
14063 }
14064
14065 /* ARM EABI attributes section.  */
14066 typedef struct
14067 {
14068   unsigned int tag;
14069   const char * name;
14070   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
14071   unsigned int type;
14072   const char ** table;
14073 } arm_attr_public_tag;
14074
14075 static const char * arm_attr_tag_CPU_arch[] =
14076   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14077    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14078    "v8-M.mainline"};
14079 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14080 static const char * arm_attr_tag_THUMB_ISA_use[] =
14081   {"No", "Thumb-1", "Thumb-2", "Yes"};
14082 static const char * arm_attr_tag_FP_arch[] =
14083   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14084    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14085 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14086 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14087   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14088    "NEON for ARMv8.1"};
14089 static const char * arm_attr_tag_PCS_config[] =
14090   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14091    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14092 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14093   {"V6", "SB", "TLS", "Unused"};
14094 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14095   {"Absolute", "PC-relative", "SB-relative", "None"};
14096 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14097   {"Absolute", "PC-relative", "None"};
14098 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14099   {"None", "direct", "GOT-indirect"};
14100 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14101   {"None", "??? 1", "2", "??? 3", "4"};
14102 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14103 static const char * arm_attr_tag_ABI_FP_denormal[] =
14104   {"Unused", "Needed", "Sign only"};
14105 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14106 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14107 static const char * arm_attr_tag_ABI_FP_number_model[] =
14108   {"Unused", "Finite", "RTABI", "IEEE 754"};
14109 static const char * arm_attr_tag_ABI_enum_size[] =
14110   {"Unused", "small", "int", "forced to int"};
14111 static const char * arm_attr_tag_ABI_HardFP_use[] =
14112   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14113 static const char * arm_attr_tag_ABI_VFP_args[] =
14114   {"AAPCS", "VFP registers", "custom", "compatible"};
14115 static const char * arm_attr_tag_ABI_WMMX_args[] =
14116   {"AAPCS", "WMMX registers", "custom"};
14117 static const char * arm_attr_tag_ABI_optimization_goals[] =
14118   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14119     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14120 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14121   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14122     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14123 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14124 static const char * arm_attr_tag_FP_HP_extension[] =
14125   {"Not Allowed", "Allowed"};
14126 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14127   {"None", "IEEE 754", "Alternative Format"};
14128 static const char * arm_attr_tag_DSP_extension[] =
14129   {"Follow architecture", "Allowed"};
14130 static const char * arm_attr_tag_MPextension_use[] =
14131   {"Not Allowed", "Allowed"};
14132 static const char * arm_attr_tag_DIV_use[] =
14133   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14134     "Allowed in v7-A with integer division extension"};
14135 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14136 static const char * arm_attr_tag_Virtualization_use[] =
14137   {"Not Allowed", "TrustZone", "Virtualization Extensions",
14138     "TrustZone and Virtualization Extensions"};
14139 static const char * arm_attr_tag_MPextension_use_legacy[] =
14140   {"Not Allowed", "Allowed"};
14141
14142 #define LOOKUP(id, name) \
14143   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14144 static arm_attr_public_tag arm_attr_public_tags[] =
14145 {
14146   {4, "CPU_raw_name", 1, NULL},
14147   {5, "CPU_name", 1, NULL},
14148   LOOKUP(6, CPU_arch),
14149   {7, "CPU_arch_profile", 0, NULL},
14150   LOOKUP(8, ARM_ISA_use),
14151   LOOKUP(9, THUMB_ISA_use),
14152   LOOKUP(10, FP_arch),
14153   LOOKUP(11, WMMX_arch),
14154   LOOKUP(12, Advanced_SIMD_arch),
14155   LOOKUP(13, PCS_config),
14156   LOOKUP(14, ABI_PCS_R9_use),
14157   LOOKUP(15, ABI_PCS_RW_data),
14158   LOOKUP(16, ABI_PCS_RO_data),
14159   LOOKUP(17, ABI_PCS_GOT_use),
14160   LOOKUP(18, ABI_PCS_wchar_t),
14161   LOOKUP(19, ABI_FP_rounding),
14162   LOOKUP(20, ABI_FP_denormal),
14163   LOOKUP(21, ABI_FP_exceptions),
14164   LOOKUP(22, ABI_FP_user_exceptions),
14165   LOOKUP(23, ABI_FP_number_model),
14166   {24, "ABI_align_needed", 0, NULL},
14167   {25, "ABI_align_preserved", 0, NULL},
14168   LOOKUP(26, ABI_enum_size),
14169   LOOKUP(27, ABI_HardFP_use),
14170   LOOKUP(28, ABI_VFP_args),
14171   LOOKUP(29, ABI_WMMX_args),
14172   LOOKUP(30, ABI_optimization_goals),
14173   LOOKUP(31, ABI_FP_optimization_goals),
14174   {32, "compatibility", 0, NULL},
14175   LOOKUP(34, CPU_unaligned_access),
14176   LOOKUP(36, FP_HP_extension),
14177   LOOKUP(38, ABI_FP_16bit_format),
14178   LOOKUP(42, MPextension_use),
14179   LOOKUP(44, DIV_use),
14180   LOOKUP(46, DSP_extension),
14181   {64, "nodefaults", 0, NULL},
14182   {65, "also_compatible_with", 0, NULL},
14183   LOOKUP(66, T2EE_use),
14184   {67, "conformance", 1, NULL},
14185   LOOKUP(68, Virtualization_use),
14186   LOOKUP(70, MPextension_use_legacy)
14187 };
14188 #undef LOOKUP
14189
14190 static unsigned char *
14191 display_arm_attribute (unsigned char * p,
14192                        const unsigned char * const end)
14193 {
14194   unsigned int tag;
14195   unsigned int len;
14196   unsigned int val;
14197   arm_attr_public_tag * attr;
14198   unsigned i;
14199   unsigned int type;
14200
14201   tag = read_uleb128 (p, &len, end);
14202   p += len;
14203   attr = NULL;
14204   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14205     {
14206       if (arm_attr_public_tags[i].tag == tag)
14207         {
14208           attr = &arm_attr_public_tags[i];
14209           break;
14210         }
14211     }
14212
14213   if (attr)
14214     {
14215       printf ("  Tag_%s: ", attr->name);
14216       switch (attr->type)
14217         {
14218         case 0:
14219           switch (tag)
14220             {
14221             case 7: /* Tag_CPU_arch_profile.  */
14222               val = read_uleb128 (p, &len, end);
14223               p += len;
14224               switch (val)
14225                 {
14226                 case 0: printf (_("None\n")); break;
14227                 case 'A': printf (_("Application\n")); break;
14228                 case 'R': printf (_("Realtime\n")); break;
14229                 case 'M': printf (_("Microcontroller\n")); break;
14230                 case 'S': printf (_("Application or Realtime\n")); break;
14231                 default: printf ("??? (%d)\n", val); break;
14232                 }
14233               break;
14234
14235             case 24: /* Tag_align_needed.  */
14236               val = read_uleb128 (p, &len, end);
14237               p += len;
14238               switch (val)
14239                 {
14240                 case 0: printf (_("None\n")); break;
14241                 case 1: printf (_("8-byte\n")); break;
14242                 case 2: printf (_("4-byte\n")); break;
14243                 case 3: printf ("??? 3\n"); break;
14244                 default:
14245                   if (val <= 12)
14246                     printf (_("8-byte and up to %d-byte extended\n"),
14247                             1 << val);
14248                   else
14249                     printf ("??? (%d)\n", val);
14250                   break;
14251                 }
14252               break;
14253
14254             case 25: /* Tag_align_preserved.  */
14255               val = read_uleb128 (p, &len, end);
14256               p += len;
14257               switch (val)
14258                 {
14259                 case 0: printf (_("None\n")); break;
14260                 case 1: printf (_("8-byte, except leaf SP\n")); break;
14261                 case 2: printf (_("8-byte\n")); break;
14262                 case 3: printf ("??? 3\n"); break;
14263                 default:
14264                   if (val <= 12)
14265                     printf (_("8-byte and up to %d-byte extended\n"),
14266                             1 << val);
14267                   else
14268                     printf ("??? (%d)\n", val);
14269                   break;
14270                 }
14271               break;
14272
14273             case 32: /* Tag_compatibility.  */
14274               {
14275                 val = read_uleb128 (p, &len, end);
14276                 p += len;
14277                 printf (_("flag = %d, vendor = "), val);
14278                 if (p < end - 1)
14279                   {
14280                     size_t maxlen = (end - p) - 1;
14281
14282                     print_symbol ((int) maxlen, (const char *) p);
14283                     p += strnlen ((char *) p, maxlen) + 1;
14284                   }
14285                 else
14286                   {
14287                     printf (_("<corrupt>"));
14288                     p = (unsigned char *) end;
14289                   }
14290                 putchar ('\n');
14291               }
14292               break;
14293
14294             case 64: /* Tag_nodefaults.  */
14295               /* PR 17531: file: 001-505008-0.01.  */
14296               if (p < end)
14297                 p++;
14298               printf (_("True\n"));
14299               break;
14300
14301             case 65: /* Tag_also_compatible_with.  */
14302               val = read_uleb128 (p, &len, end);
14303               p += len;
14304               if (val == 6 /* Tag_CPU_arch.  */)
14305                 {
14306                   val = read_uleb128 (p, &len, end);
14307                   p += len;
14308                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14309                     printf ("??? (%d)\n", val);
14310                   else
14311                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14312                 }
14313               else
14314                 printf ("???\n");
14315               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
14316                 ;
14317               break;
14318
14319             default:
14320               printf (_("<unknown: %d>\n"), tag);
14321               break;
14322             }
14323           return p;
14324
14325         case 1:
14326           return display_tag_value (-1, p, end);
14327         case 2:
14328           return display_tag_value (0, p, end);
14329
14330         default:
14331           assert (attr->type & 0x80);
14332           val = read_uleb128 (p, &len, end);
14333           p += len;
14334           type = attr->type & 0x7f;
14335           if (val >= type)
14336             printf ("??? (%d)\n", val);
14337           else
14338             printf ("%s\n", attr->table[val]);
14339           return p;
14340         }
14341     }
14342
14343   return display_tag_value (tag, p, end);
14344 }
14345
14346 static unsigned char *
14347 display_gnu_attribute (unsigned char * p,
14348                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14349                        const unsigned char * const end)
14350 {
14351   int tag;
14352   unsigned int len;
14353   unsigned int val;
14354
14355   tag = read_uleb128 (p, &len, end);
14356   p += len;
14357
14358   /* Tag_compatibility is the only generic GNU attribute defined at
14359      present.  */
14360   if (tag == 32)
14361     {
14362       val = read_uleb128 (p, &len, end);
14363       p += len;
14364
14365       printf (_("flag = %d, vendor = "), val);
14366       if (p == end)
14367         {
14368           printf (_("<corrupt>\n"));
14369           warn (_("corrupt vendor attribute\n"));
14370         }
14371       else
14372         {
14373           if (p < end - 1)
14374             {
14375               size_t maxlen = (end - p) - 1;
14376
14377               print_symbol ((int) maxlen, (const char *) p);
14378               p += strnlen ((char *) p, maxlen) + 1;
14379             }
14380           else
14381             {
14382               printf (_("<corrupt>"));
14383               p = (unsigned char *) end;
14384             }
14385           putchar ('\n');
14386         }
14387       return p;
14388     }
14389
14390   if ((tag & 2) == 0 && display_proc_gnu_attribute)
14391     return display_proc_gnu_attribute (p, tag, end);
14392
14393   return display_tag_value (tag, p, end);
14394 }
14395
14396 static unsigned char *
14397 display_power_gnu_attribute (unsigned char * p,
14398                              unsigned int tag,
14399                              const unsigned char * const end)
14400 {
14401   unsigned int len;
14402   unsigned int val;
14403
14404   if (tag == Tag_GNU_Power_ABI_FP)
14405     {
14406       val = read_uleb128 (p, &len, end);
14407       p += len;
14408       printf ("  Tag_GNU_Power_ABI_FP: ");
14409       if (len == 0)
14410         {
14411           printf (_("<corrupt>\n"));
14412           return p;
14413         }
14414
14415       if (val > 15)
14416         printf ("(%#x), ", val);
14417
14418       switch (val & 3)
14419         {
14420         case 0:
14421           printf (_("unspecified hard/soft float, "));
14422           break;
14423         case 1:
14424           printf (_("hard float, "));
14425           break;
14426         case 2:
14427           printf (_("soft float, "));
14428           break;
14429         case 3:
14430           printf (_("single-precision hard float, "));
14431           break;
14432         }
14433
14434       switch (val & 0xC)
14435         {
14436         case 0:
14437           printf (_("unspecified long double\n"));
14438           break;
14439         case 4:
14440           printf (_("128-bit IBM long double\n"));
14441           break;
14442         case 8:
14443           printf (_("64-bit long double\n"));
14444           break;
14445         case 12:
14446           printf (_("128-bit IEEE long double\n"));
14447           break;
14448         }
14449       return p;
14450     }
14451
14452   if (tag == Tag_GNU_Power_ABI_Vector)
14453     {
14454       val = read_uleb128 (p, &len, end);
14455       p += len;
14456       printf ("  Tag_GNU_Power_ABI_Vector: ");
14457       if (len == 0)
14458         {
14459           printf (_("<corrupt>\n"));
14460           return p;
14461         }
14462
14463       if (val > 3)
14464         printf ("(%#x), ", val);
14465
14466       switch (val & 3)
14467         {
14468         case 0:
14469           printf (_("unspecified\n"));
14470           break;
14471         case 1:
14472           printf (_("generic\n"));
14473           break;
14474         case 2:
14475           printf ("AltiVec\n");
14476           break;
14477         case 3:
14478           printf ("SPE\n");
14479           break;
14480         }
14481       return p;
14482     }
14483
14484   if (tag == Tag_GNU_Power_ABI_Struct_Return)
14485     {
14486       val = read_uleb128 (p, &len, end);
14487       p += len;
14488       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
14489       if (len == 0)
14490         {
14491           printf (_("<corrupt>\n"));
14492           return p;
14493         }
14494
14495       if (val > 2)
14496         printf ("(%#x), ", val);
14497
14498       switch (val & 3)
14499         {
14500         case 0:
14501           printf (_("unspecified\n"));
14502           break;
14503         case 1:
14504           printf ("r3/r4\n");
14505           break;
14506         case 2:
14507           printf (_("memory\n"));
14508           break;
14509         case 3:
14510           printf ("???\n");
14511           break;
14512         }
14513       return p;
14514     }
14515
14516   return display_tag_value (tag & 1, p, end);
14517 }
14518
14519 static unsigned char *
14520 display_s390_gnu_attribute (unsigned char * p,
14521                             unsigned int tag,
14522                             const unsigned char * const end)
14523 {
14524   unsigned int len;
14525   int val;
14526
14527   if (tag == Tag_GNU_S390_ABI_Vector)
14528     {
14529       val = read_uleb128 (p, &len, end);
14530       p += len;
14531       printf ("  Tag_GNU_S390_ABI_Vector: ");
14532
14533       switch (val)
14534         {
14535         case 0:
14536           printf (_("any\n"));
14537           break;
14538         case 1:
14539           printf (_("software\n"));
14540           break;
14541         case 2:
14542           printf (_("hardware\n"));
14543           break;
14544         default:
14545           printf ("??? (%d)\n", val);
14546           break;
14547         }
14548       return p;
14549    }
14550
14551   return display_tag_value (tag & 1, p, end);
14552 }
14553
14554 static void
14555 display_sparc_hwcaps (unsigned int mask)
14556 {
14557   if (mask)
14558     {
14559       bfd_boolean first = TRUE;
14560
14561       if (mask & ELF_SPARC_HWCAP_MUL32)
14562         fputs ("mul32", stdout), first = FALSE;
14563       if (mask & ELF_SPARC_HWCAP_DIV32)
14564         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14565       if (mask & ELF_SPARC_HWCAP_FSMULD)
14566         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14567       if (mask & ELF_SPARC_HWCAP_V8PLUS)
14568         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14569       if (mask & ELF_SPARC_HWCAP_POPC)
14570         printf ("%spopc", first ? "" : "|"), first = FALSE;
14571       if (mask & ELF_SPARC_HWCAP_VIS)
14572         printf ("%svis", first ? "" : "|"), first = FALSE;
14573       if (mask & ELF_SPARC_HWCAP_VIS2)
14574         printf ("%svis2", first ? "" : "|"), first = FALSE;
14575       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14576         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14577       if (mask & ELF_SPARC_HWCAP_FMAF)
14578         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14579       if (mask & ELF_SPARC_HWCAP_VIS3)
14580         printf ("%svis3", first ? "" : "|"), first = FALSE;
14581       if (mask & ELF_SPARC_HWCAP_HPC)
14582         printf ("%shpc", first ? "" : "|"), first = FALSE;
14583       if (mask & ELF_SPARC_HWCAP_RANDOM)
14584         printf ("%srandom", first ? "" : "|"), first = FALSE;
14585       if (mask & ELF_SPARC_HWCAP_TRANS)
14586         printf ("%strans", first ? "" : "|"), first = FALSE;
14587       if (mask & ELF_SPARC_HWCAP_FJFMAU)
14588         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14589       if (mask & ELF_SPARC_HWCAP_IMA)
14590         printf ("%sima", first ? "" : "|"), first = FALSE;
14591       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14592         printf ("%scspare", first ? "" : "|"), first = FALSE;
14593     }
14594   else
14595     fputc ('0', stdout);
14596   fputc ('\n', stdout);
14597 }
14598
14599 static void
14600 display_sparc_hwcaps2 (unsigned int mask)
14601 {
14602   if (mask)
14603     {
14604       bfd_boolean first = TRUE;
14605
14606       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14607         fputs ("fjathplus", stdout), first = FALSE;
14608       if (mask & ELF_SPARC_HWCAP2_VIS3B)
14609         printf ("%svis3b", first ? "" : "|"), first = FALSE;
14610       if (mask & ELF_SPARC_HWCAP2_ADP)
14611         printf ("%sadp", first ? "" : "|"), first = FALSE;
14612       if (mask & ELF_SPARC_HWCAP2_SPARC5)
14613         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14614       if (mask & ELF_SPARC_HWCAP2_MWAIT)
14615         printf ("%smwait", first ? "" : "|"), first = FALSE;
14616       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14617         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14618       if (mask & ELF_SPARC_HWCAP2_XMONT)
14619         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14620       if (mask & ELF_SPARC_HWCAP2_NSEC)
14621         printf ("%snsec", first ? "" : "|"), first = FALSE;
14622       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14623         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14624       if (mask & ELF_SPARC_HWCAP2_FJDES)
14625         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14626       if (mask & ELF_SPARC_HWCAP2_FJAES)
14627         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14628     }
14629   else
14630     fputc ('0', stdout);
14631   fputc ('\n', stdout);
14632 }
14633
14634 static unsigned char *
14635 display_sparc_gnu_attribute (unsigned char * p,
14636                              unsigned int tag,
14637                              const unsigned char * const end)
14638 {
14639   unsigned int len;
14640   int val;
14641
14642   if (tag == Tag_GNU_Sparc_HWCAPS)
14643     {
14644       val = read_uleb128 (p, &len, end);
14645       p += len;
14646       printf ("  Tag_GNU_Sparc_HWCAPS: ");
14647       display_sparc_hwcaps (val);
14648       return p;
14649     }
14650   if (tag == Tag_GNU_Sparc_HWCAPS2)
14651     {
14652       val = read_uleb128 (p, &len, end);
14653       p += len;
14654       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
14655       display_sparc_hwcaps2 (val);
14656       return p;
14657     }
14658
14659   return display_tag_value (tag, p, end);
14660 }
14661
14662 static void
14663 print_mips_fp_abi_value (unsigned int val)
14664 {
14665   switch (val)
14666     {
14667     case Val_GNU_MIPS_ABI_FP_ANY:
14668       printf (_("Hard or soft float\n"));
14669       break;
14670     case Val_GNU_MIPS_ABI_FP_DOUBLE:
14671       printf (_("Hard float (double precision)\n"));
14672       break;
14673     case Val_GNU_MIPS_ABI_FP_SINGLE:
14674       printf (_("Hard float (single precision)\n"));
14675       break;
14676     case Val_GNU_MIPS_ABI_FP_SOFT:
14677       printf (_("Soft float\n"));
14678       break;
14679     case Val_GNU_MIPS_ABI_FP_OLD_64:
14680       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14681       break;
14682     case Val_GNU_MIPS_ABI_FP_XX:
14683       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14684       break;
14685     case Val_GNU_MIPS_ABI_FP_64:
14686       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14687       break;
14688     case Val_GNU_MIPS_ABI_FP_64A:
14689       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14690       break;
14691     case Val_GNU_MIPS_ABI_FP_NAN2008:
14692       printf (_("NaN 2008 compatibility\n"));
14693       break;
14694     default:
14695       printf ("??? (%d)\n", val);
14696       break;
14697     }
14698 }
14699
14700 static unsigned char *
14701 display_mips_gnu_attribute (unsigned char * p,
14702                             unsigned int tag,
14703                             const unsigned char * const end)
14704 {
14705   if (tag == Tag_GNU_MIPS_ABI_FP)
14706     {
14707       unsigned int len;
14708       unsigned int val;
14709
14710       val = read_uleb128 (p, &len, end);
14711       p += len;
14712       printf ("  Tag_GNU_MIPS_ABI_FP: ");
14713
14714       print_mips_fp_abi_value (val);
14715
14716       return p;
14717    }
14718
14719   if (tag == Tag_GNU_MIPS_ABI_MSA)
14720     {
14721       unsigned int len;
14722       unsigned int val;
14723
14724       val = read_uleb128 (p, &len, end);
14725       p += len;
14726       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
14727
14728       switch (val)
14729         {
14730         case Val_GNU_MIPS_ABI_MSA_ANY:
14731           printf (_("Any MSA or not\n"));
14732           break;
14733         case Val_GNU_MIPS_ABI_MSA_128:
14734           printf (_("128-bit MSA\n"));
14735           break;
14736         default:
14737           printf ("??? (%d)\n", val);
14738           break;
14739         }
14740       return p;
14741     }
14742
14743   return display_tag_value (tag & 1, p, end);
14744 }
14745
14746 static unsigned char *
14747 display_tic6x_attribute (unsigned char * p,
14748                          const unsigned char * const end)
14749 {
14750   unsigned int tag;
14751   unsigned int len;
14752   int val;
14753
14754   tag = read_uleb128 (p, &len, end);
14755   p += len;
14756
14757   switch (tag)
14758     {
14759     case Tag_ISA:
14760       val = read_uleb128 (p, &len, end);
14761       p += len;
14762       printf ("  Tag_ISA: ");
14763
14764       switch (val)
14765         {
14766         case C6XABI_Tag_ISA_none:
14767           printf (_("None\n"));
14768           break;
14769         case C6XABI_Tag_ISA_C62X:
14770           printf ("C62x\n");
14771           break;
14772         case C6XABI_Tag_ISA_C67X:
14773           printf ("C67x\n");
14774           break;
14775         case C6XABI_Tag_ISA_C67XP:
14776           printf ("C67x+\n");
14777           break;
14778         case C6XABI_Tag_ISA_C64X:
14779           printf ("C64x\n");
14780           break;
14781         case C6XABI_Tag_ISA_C64XP:
14782           printf ("C64x+\n");
14783           break;
14784         case C6XABI_Tag_ISA_C674X:
14785           printf ("C674x\n");
14786           break;
14787         default:
14788           printf ("??? (%d)\n", val);
14789           break;
14790         }
14791       return p;
14792
14793     case Tag_ABI_wchar_t:
14794       val = read_uleb128 (p, &len, end);
14795       p += len;
14796       printf ("  Tag_ABI_wchar_t: ");
14797       switch (val)
14798         {
14799         case 0:
14800           printf (_("Not used\n"));
14801           break;
14802         case 1:
14803           printf (_("2 bytes\n"));
14804           break;
14805         case 2:
14806           printf (_("4 bytes\n"));
14807           break;
14808         default:
14809           printf ("??? (%d)\n", val);
14810           break;
14811         }
14812       return p;
14813
14814     case Tag_ABI_stack_align_needed:
14815       val = read_uleb128 (p, &len, end);
14816       p += len;
14817       printf ("  Tag_ABI_stack_align_needed: ");
14818       switch (val)
14819         {
14820         case 0:
14821           printf (_("8-byte\n"));
14822           break;
14823         case 1:
14824           printf (_("16-byte\n"));
14825           break;
14826         default:
14827           printf ("??? (%d)\n", val);
14828           break;
14829         }
14830       return p;
14831
14832     case Tag_ABI_stack_align_preserved:
14833       val = read_uleb128 (p, &len, end);
14834       p += len;
14835       printf ("  Tag_ABI_stack_align_preserved: ");
14836       switch (val)
14837         {
14838         case 0:
14839           printf (_("8-byte\n"));
14840           break;
14841         case 1:
14842           printf (_("16-byte\n"));
14843           break;
14844         default:
14845           printf ("??? (%d)\n", val);
14846           break;
14847         }
14848       return p;
14849
14850     case Tag_ABI_DSBT:
14851       val = read_uleb128 (p, &len, end);
14852       p += len;
14853       printf ("  Tag_ABI_DSBT: ");
14854       switch (val)
14855         {
14856         case 0:
14857           printf (_("DSBT addressing not used\n"));
14858           break;
14859         case 1:
14860           printf (_("DSBT addressing used\n"));
14861           break;
14862         default:
14863           printf ("??? (%d)\n", val);
14864           break;
14865         }
14866       return p;
14867
14868     case Tag_ABI_PID:
14869       val = read_uleb128 (p, &len, end);
14870       p += len;
14871       printf ("  Tag_ABI_PID: ");
14872       switch (val)
14873         {
14874         case 0:
14875           printf (_("Data addressing position-dependent\n"));
14876           break;
14877         case 1:
14878           printf (_("Data addressing position-independent, GOT near DP\n"));
14879           break;
14880         case 2:
14881           printf (_("Data addressing position-independent, GOT far from DP\n"));
14882           break;
14883         default:
14884           printf ("??? (%d)\n", val);
14885           break;
14886         }
14887       return p;
14888
14889     case Tag_ABI_PIC:
14890       val = read_uleb128 (p, &len, end);
14891       p += len;
14892       printf ("  Tag_ABI_PIC: ");
14893       switch (val)
14894         {
14895         case 0:
14896           printf (_("Code addressing position-dependent\n"));
14897           break;
14898         case 1:
14899           printf (_("Code addressing position-independent\n"));
14900           break;
14901         default:
14902           printf ("??? (%d)\n", val);
14903           break;
14904         }
14905       return p;
14906
14907     case Tag_ABI_array_object_alignment:
14908       val = read_uleb128 (p, &len, end);
14909       p += len;
14910       printf ("  Tag_ABI_array_object_alignment: ");
14911       switch (val)
14912         {
14913         case 0:
14914           printf (_("8-byte\n"));
14915           break;
14916         case 1:
14917           printf (_("4-byte\n"));
14918           break;
14919         case 2:
14920           printf (_("16-byte\n"));
14921           break;
14922         default:
14923           printf ("??? (%d)\n", val);
14924           break;
14925         }
14926       return p;
14927
14928     case Tag_ABI_array_object_align_expected:
14929       val = read_uleb128 (p, &len, end);
14930       p += len;
14931       printf ("  Tag_ABI_array_object_align_expected: ");
14932       switch (val)
14933         {
14934         case 0:
14935           printf (_("8-byte\n"));
14936           break;
14937         case 1:
14938           printf (_("4-byte\n"));
14939           break;
14940         case 2:
14941           printf (_("16-byte\n"));
14942           break;
14943         default:
14944           printf ("??? (%d)\n", val);
14945           break;
14946         }
14947       return p;
14948
14949     case Tag_ABI_compatibility:
14950       {
14951         val = read_uleb128 (p, &len, end);
14952         p += len;
14953         printf ("  Tag_ABI_compatibility: ");
14954         printf (_("flag = %d, vendor = "), val);
14955         if (p < end - 1)
14956           {
14957             size_t maxlen = (end - p) - 1;
14958
14959             print_symbol ((int) maxlen, (const char *) p);
14960             p += strnlen ((char *) p, maxlen) + 1;
14961           }
14962         else
14963           {
14964             printf (_("<corrupt>"));
14965             p = (unsigned char *) end;
14966           }
14967         putchar ('\n');
14968         return p;
14969       }
14970
14971     case Tag_ABI_conformance:
14972       {
14973         printf ("  Tag_ABI_conformance: \"");
14974         if (p < end - 1)
14975           {
14976             size_t maxlen = (end - p) - 1;
14977
14978             print_symbol ((int) maxlen, (const char *) p);
14979             p += strnlen ((char *) p, maxlen) + 1;
14980           }
14981         else
14982           {
14983             printf (_("<corrupt>"));
14984             p = (unsigned char *) end;
14985           }
14986         printf ("\"\n");
14987         return p;
14988       }
14989     }
14990
14991   return display_tag_value (tag, p, end);
14992 }
14993
14994 static void
14995 display_raw_attribute (unsigned char * p, unsigned char const * const end)
14996 {
14997   unsigned long addr = 0;
14998   size_t bytes = end - p;
14999
15000   assert (end > p);
15001   while (bytes)
15002     {
15003       int j;
15004       int k;
15005       int lbytes = (bytes > 16 ? 16 : bytes);
15006
15007       printf ("  0x%8.8lx ", addr);
15008
15009       for (j = 0; j < 16; j++)
15010         {
15011           if (j < lbytes)
15012             printf ("%2.2x", p[j]);
15013           else
15014             printf ("  ");
15015
15016           if ((j & 3) == 3)
15017             printf (" ");
15018         }
15019
15020       for (j = 0; j < lbytes; j++)
15021         {
15022           k = p[j];
15023           if (k >= ' ' && k < 0x7f)
15024             printf ("%c", k);
15025           else
15026             printf (".");
15027         }
15028
15029       putchar ('\n');
15030
15031       p  += lbytes;
15032       bytes -= lbytes;
15033       addr += lbytes;
15034     }
15035
15036   putchar ('\n');
15037 }
15038
15039 static unsigned char *
15040 display_msp430x_attribute (unsigned char * p,
15041                            const unsigned char * const end)
15042 {
15043   unsigned int len;
15044   unsigned int val;
15045   unsigned int tag;
15046
15047   tag = read_uleb128 (p, & len, end);
15048   p += len;
15049
15050   switch (tag)
15051     {
15052     case OFBA_MSPABI_Tag_ISA:
15053       val = read_uleb128 (p, &len, end);
15054       p += len;
15055       printf ("  Tag_ISA: ");
15056       switch (val)
15057         {
15058         case 0: printf (_("None\n")); break;
15059         case 1: printf (_("MSP430\n")); break;
15060         case 2: printf (_("MSP430X\n")); break;
15061         default: printf ("??? (%d)\n", val); break;
15062         }
15063       break;
15064
15065     case OFBA_MSPABI_Tag_Code_Model:
15066       val = read_uleb128 (p, &len, end);
15067       p += len;
15068       printf ("  Tag_Code_Model: ");
15069       switch (val)
15070         {
15071         case 0: printf (_("None\n")); break;
15072         case 1: printf (_("Small\n")); break;
15073         case 2: printf (_("Large\n")); break;
15074         default: printf ("??? (%d)\n", val); break;
15075         }
15076       break;
15077
15078     case OFBA_MSPABI_Tag_Data_Model:
15079       val = read_uleb128 (p, &len, end);
15080       p += len;
15081       printf ("  Tag_Data_Model: ");
15082       switch (val)
15083         {
15084         case 0: printf (_("None\n")); break;
15085         case 1: printf (_("Small\n")); break;
15086         case 2: printf (_("Large\n")); break;
15087         case 3: printf (_("Restricted Large\n")); break;
15088         default: printf ("??? (%d)\n", val); break;
15089         }
15090       break;
15091
15092     default:
15093       printf (_("  <unknown tag %d>: "), tag);
15094
15095       if (tag & 1)
15096         {
15097           putchar ('"');
15098           if (p < end - 1)
15099             {
15100               size_t maxlen = (end - p) - 1;
15101
15102               print_symbol ((int) maxlen, (const char *) p);
15103               p += strnlen ((char *) p, maxlen) + 1;
15104             }
15105           else
15106             {
15107               printf (_("<corrupt>"));
15108               p = (unsigned char *) end;
15109             }
15110           printf ("\"\n");
15111         }
15112       else
15113         {
15114           val = read_uleb128 (p, &len, end);
15115           p += len;
15116           printf ("%d (0x%x)\n", val, val);
15117         }
15118       break;
15119    }
15120
15121   assert (p <= end);
15122   return p;
15123 }
15124
15125 static bfd_boolean
15126 process_attributes (Filedata * filedata,
15127                     const char * public_name,
15128                     unsigned int proc_type,
15129                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15130                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15131 {
15132   Elf_Internal_Shdr * sect;
15133   unsigned i;
15134   bfd_boolean res = TRUE;
15135
15136   /* Find the section header so that we get the size.  */
15137   for (i = 0, sect = filedata->section_headers;
15138        i < filedata->file_header.e_shnum;
15139        i++, sect++)
15140     {
15141       unsigned char * contents;
15142       unsigned char * p;
15143
15144       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15145         continue;
15146
15147       contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15148                                              sect->sh_size, _("attributes"));
15149       if (contents == NULL)
15150         {
15151           res = FALSE;
15152           continue;
15153         }
15154
15155       p = contents;
15156       /* The first character is the version of the attributes.
15157          Currently only version 1, (aka 'A') is recognised here.  */
15158       if (*p != 'A')
15159         {
15160           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15161           res = FALSE;
15162         }
15163       else
15164         {
15165           bfd_vma section_len;
15166
15167           section_len = sect->sh_size - 1;
15168           p++;
15169
15170           while (section_len > 0)
15171             {
15172               bfd_vma attr_len;
15173               unsigned int namelen;
15174               bfd_boolean public_section;
15175               bfd_boolean gnu_section;
15176
15177               if (section_len <= 4)
15178                 {
15179                   error (_("Tag section ends prematurely\n"));
15180                   res = FALSE;
15181                   break;
15182                 }
15183               attr_len = byte_get (p, 4);
15184               p += 4;
15185
15186               if (attr_len > section_len)
15187                 {
15188                   error (_("Bad attribute length (%u > %u)\n"),
15189                           (unsigned) attr_len, (unsigned) section_len);
15190                   attr_len = section_len;
15191                   res = FALSE;
15192                 }
15193               /* PR 17531: file: 001-101425-0.004  */
15194               else if (attr_len < 5)
15195                 {
15196                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
15197                   res = FALSE;
15198                   break;
15199                 }
15200
15201               section_len -= attr_len;
15202               attr_len -= 4;
15203
15204               namelen = strnlen ((char *) p, attr_len) + 1;
15205               if (namelen == 0 || namelen >= attr_len)
15206                 {
15207                   error (_("Corrupt attribute section name\n"));
15208                   res = FALSE;
15209                   break;
15210                 }
15211
15212               printf (_("Attribute Section: "));
15213               print_symbol (INT_MAX, (const char *) p);
15214               putchar ('\n');
15215
15216               if (public_name && streq ((char *) p, public_name))
15217                 public_section = TRUE;
15218               else
15219                 public_section = FALSE;
15220
15221               if (streq ((char *) p, "gnu"))
15222                 gnu_section = TRUE;
15223               else
15224                 gnu_section = FALSE;
15225
15226               p += namelen;
15227               attr_len -= namelen;
15228
15229               while (attr_len > 0 && p < contents + sect->sh_size)
15230                 {
15231                   int tag;
15232                   int val;
15233                   bfd_vma size;
15234                   unsigned char * end;
15235
15236                   /* PR binutils/17531: Safe handling of corrupt files.  */
15237                   if (attr_len < 6)
15238                     {
15239                       error (_("Unused bytes at end of section\n"));
15240                       res = FALSE;
15241                       section_len = 0;
15242                       break;
15243                     }
15244
15245                   tag = *(p++);
15246                   size = byte_get (p, 4);
15247                   if (size > attr_len)
15248                     {
15249                       error (_("Bad subsection length (%u > %u)\n"),
15250                               (unsigned) size, (unsigned) attr_len);
15251                       res = FALSE;
15252                       size = attr_len;
15253                     }
15254                   /* PR binutils/17531: Safe handling of corrupt files.  */
15255                   if (size < 6)
15256                     {
15257                       error (_("Bad subsection length (%u < 6)\n"),
15258                               (unsigned) size);
15259                       res = FALSE;
15260                       section_len = 0;
15261                       break;
15262                     }
15263
15264                   attr_len -= size;
15265                   end = p + size - 1;
15266                   assert (end <= contents + sect->sh_size);
15267                   p += 4;
15268
15269                   switch (tag)
15270                     {
15271                     case 1:
15272                       printf (_("File Attributes\n"));
15273                       break;
15274                     case 2:
15275                       printf (_("Section Attributes:"));
15276                       goto do_numlist;
15277                     case 3:
15278                       printf (_("Symbol Attributes:"));
15279                       /* Fall through.  */
15280                     do_numlist:
15281                       for (;;)
15282                         {
15283                           unsigned int j;
15284
15285                           val = read_uleb128 (p, &j, end);
15286                           p += j;
15287                           if (val == 0)
15288                             break;
15289                           printf (" %d", val);
15290                         }
15291                       printf ("\n");
15292                       break;
15293                     default:
15294                       printf (_("Unknown tag: %d\n"), tag);
15295                       public_section = FALSE;
15296                       break;
15297                     }
15298
15299                   if (public_section && display_pub_attribute != NULL)
15300                     {
15301                       while (p < end)
15302                         p = display_pub_attribute (p, end);
15303                       assert (p == end);
15304                     }
15305                   else if (gnu_section && display_proc_gnu_attribute != NULL)
15306                     {
15307                       while (p < end)
15308                         p = display_gnu_attribute (p,
15309                                                    display_proc_gnu_attribute,
15310                                                    end);
15311                       assert (p == end);
15312                     }
15313                   else if (p < end)
15314                     {
15315                       printf (_("  Unknown attribute:\n"));
15316                       display_raw_attribute (p, end);
15317                       p = end;
15318                     }
15319                   else
15320                     attr_len = 0;
15321                 }
15322             }
15323         }
15324
15325       free (contents);
15326     }
15327
15328   return res;
15329 }
15330
15331 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15332    Print the Address, Access and Initial fields of an entry at VMA ADDR
15333    and return the VMA of the next entry, or -1 if there was a problem.
15334    Does not read from DATA_END or beyond.  */
15335
15336 static bfd_vma
15337 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15338                       unsigned char * data_end)
15339 {
15340   printf ("  ");
15341   print_vma (addr, LONG_HEX);
15342   printf (" ");
15343   if (addr < pltgot + 0xfff0)
15344     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15345   else
15346     printf ("%10s", "");
15347   printf (" ");
15348   if (data == NULL)
15349     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15350   else
15351     {
15352       bfd_vma entry;
15353       unsigned char * from = data + addr - pltgot;
15354
15355       if (from + (is_32bit_elf ? 4 : 8) > data_end)
15356         {
15357           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15358           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15359           return (bfd_vma) -1;
15360         }
15361       else
15362         {
15363           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15364           print_vma (entry, LONG_HEX);
15365         }
15366     }
15367   return addr + (is_32bit_elf ? 4 : 8);
15368 }
15369
15370 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15371    PLTGOT.  Print the Address and Initial fields of an entry at VMA
15372    ADDR and return the VMA of the next entry.  */
15373
15374 static bfd_vma
15375 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15376 {
15377   printf ("  ");
15378   print_vma (addr, LONG_HEX);
15379   printf (" ");
15380   if (data == NULL)
15381     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15382   else
15383     {
15384       bfd_vma entry;
15385
15386       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15387       print_vma (entry, LONG_HEX);
15388     }
15389   return addr + (is_32bit_elf ? 4 : 8);
15390 }
15391
15392 static void
15393 print_mips_ases (unsigned int mask)
15394 {
15395   if (mask & AFL_ASE_DSP)
15396     fputs ("\n\tDSP ASE", stdout);
15397   if (mask & AFL_ASE_DSPR2)
15398     fputs ("\n\tDSP R2 ASE", stdout);
15399   if (mask & AFL_ASE_DSPR3)
15400     fputs ("\n\tDSP R3 ASE", stdout);
15401   if (mask & AFL_ASE_EVA)
15402     fputs ("\n\tEnhanced VA Scheme", stdout);
15403   if (mask & AFL_ASE_MCU)
15404     fputs ("\n\tMCU (MicroController) ASE", stdout);
15405   if (mask & AFL_ASE_MDMX)
15406     fputs ("\n\tMDMX ASE", stdout);
15407   if (mask & AFL_ASE_MIPS3D)
15408     fputs ("\n\tMIPS-3D ASE", stdout);
15409   if (mask & AFL_ASE_MT)
15410     fputs ("\n\tMT ASE", stdout);
15411   if (mask & AFL_ASE_SMARTMIPS)
15412     fputs ("\n\tSmartMIPS ASE", stdout);
15413   if (mask & AFL_ASE_VIRT)
15414     fputs ("\n\tVZ ASE", stdout);
15415   if (mask & AFL_ASE_MSA)
15416     fputs ("\n\tMSA ASE", stdout);
15417   if (mask & AFL_ASE_MIPS16)
15418     fputs ("\n\tMIPS16 ASE", stdout);
15419   if (mask & AFL_ASE_MICROMIPS)
15420     fputs ("\n\tMICROMIPS ASE", stdout);
15421   if (mask & AFL_ASE_XPA)
15422     fputs ("\n\tXPA ASE", stdout);
15423   if (mask & AFL_ASE_MIPS16E2)
15424     fputs ("\n\tMIPS16e2 ASE", stdout);
15425   if (mask == 0)
15426     fprintf (stdout, "\n\t%s", _("None"));
15427   else if ((mask & ~AFL_ASE_MASK) != 0)
15428     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15429 }
15430
15431 static void
15432 print_mips_isa_ext (unsigned int isa_ext)
15433 {
15434   switch (isa_ext)
15435     {
15436     case 0:
15437       fputs (_("None"), stdout);
15438       break;
15439     case AFL_EXT_XLR:
15440       fputs ("RMI XLR", stdout);
15441       break;
15442     case AFL_EXT_OCTEON3:
15443       fputs ("Cavium Networks Octeon3", stdout);
15444       break;
15445     case AFL_EXT_OCTEON2:
15446       fputs ("Cavium Networks Octeon2", stdout);
15447       break;
15448     case AFL_EXT_OCTEONP:
15449       fputs ("Cavium Networks OcteonP", stdout);
15450       break;
15451     case AFL_EXT_LOONGSON_3A:
15452       fputs ("Loongson 3A", stdout);
15453       break;
15454     case AFL_EXT_OCTEON:
15455       fputs ("Cavium Networks Octeon", stdout);
15456       break;
15457     case AFL_EXT_5900:
15458       fputs ("Toshiba R5900", stdout);
15459       break;
15460     case AFL_EXT_4650:
15461       fputs ("MIPS R4650", stdout);
15462       break;
15463     case AFL_EXT_4010:
15464       fputs ("LSI R4010", stdout);
15465       break;
15466     case AFL_EXT_4100:
15467       fputs ("NEC VR4100", stdout);
15468       break;
15469     case AFL_EXT_3900:
15470       fputs ("Toshiba R3900", stdout);
15471       break;
15472     case AFL_EXT_10000:
15473       fputs ("MIPS R10000", stdout);
15474       break;
15475     case AFL_EXT_SB1:
15476       fputs ("Broadcom SB-1", stdout);
15477       break;
15478     case AFL_EXT_4111:
15479       fputs ("NEC VR4111/VR4181", stdout);
15480       break;
15481     case AFL_EXT_4120:
15482       fputs ("NEC VR4120", stdout);
15483       break;
15484     case AFL_EXT_5400:
15485       fputs ("NEC VR5400", stdout);
15486       break;
15487     case AFL_EXT_5500:
15488       fputs ("NEC VR5500", stdout);
15489       break;
15490     case AFL_EXT_LOONGSON_2E:
15491       fputs ("ST Microelectronics Loongson 2E", stdout);
15492       break;
15493     case AFL_EXT_LOONGSON_2F:
15494       fputs ("ST Microelectronics Loongson 2F", stdout);
15495       break;
15496     case AFL_EXT_INTERAPTIV_MR2:
15497       fputs ("Imagination interAptiv MR2", stdout);
15498       break;
15499     default:
15500       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15501     }
15502 }
15503
15504 static signed int
15505 get_mips_reg_size (int reg_size)
15506 {
15507   return (reg_size == AFL_REG_NONE) ? 0
15508          : (reg_size == AFL_REG_32) ? 32
15509          : (reg_size == AFL_REG_64) ? 64
15510          : (reg_size == AFL_REG_128) ? 128
15511          : -1;
15512 }
15513
15514 static bfd_boolean
15515 process_mips_specific (Filedata * filedata)
15516 {
15517   Elf_Internal_Dyn * entry;
15518   Elf_Internal_Shdr *sect = NULL;
15519   size_t liblist_offset = 0;
15520   size_t liblistno = 0;
15521   size_t conflictsno = 0;
15522   size_t options_offset = 0;
15523   size_t conflicts_offset = 0;
15524   size_t pltrelsz = 0;
15525   size_t pltrel = 0;
15526   bfd_vma pltgot = 0;
15527   bfd_vma mips_pltgot = 0;
15528   bfd_vma jmprel = 0;
15529   bfd_vma local_gotno = 0;
15530   bfd_vma gotsym = 0;
15531   bfd_vma symtabno = 0;
15532   bfd_boolean res = TRUE;
15533
15534   if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
15535                             display_mips_gnu_attribute))
15536     res = FALSE;
15537
15538   sect = find_section (filedata, ".MIPS.abiflags");
15539
15540   if (sect != NULL)
15541     {
15542       Elf_External_ABIFlags_v0 *abiflags_ext;
15543       Elf_Internal_ABIFlags_v0 abiflags_in;
15544
15545       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15546         {
15547           error (_("Corrupt MIPS ABI Flags section.\n"));
15548           res = FALSE;
15549         }
15550       else
15551         {
15552           abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
15553                                    sect->sh_size, _("MIPS ABI Flags section"));
15554           if (abiflags_ext)
15555             {
15556               abiflags_in.version = BYTE_GET (abiflags_ext->version);
15557               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15558               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15559               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15560               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15561               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15562               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15563               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15564               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15565               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15566               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15567
15568               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15569               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15570               if (abiflags_in.isa_rev > 1)
15571                 printf ("r%d", abiflags_in.isa_rev);
15572               printf ("\nGPR size: %d",
15573                       get_mips_reg_size (abiflags_in.gpr_size));
15574               printf ("\nCPR1 size: %d",
15575                       get_mips_reg_size (abiflags_in.cpr1_size));
15576               printf ("\nCPR2 size: %d",
15577                       get_mips_reg_size (abiflags_in.cpr2_size));
15578               fputs ("\nFP ABI: ", stdout);
15579               print_mips_fp_abi_value (abiflags_in.fp_abi);
15580               fputs ("ISA Extension: ", stdout);
15581               print_mips_isa_ext (abiflags_in.isa_ext);
15582               fputs ("\nASEs:", stdout);
15583               print_mips_ases (abiflags_in.ases);
15584               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15585               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15586               fputc ('\n', stdout);
15587               free (abiflags_ext);
15588             }
15589         }
15590     }
15591
15592   /* We have a lot of special sections.  Thanks SGI!  */
15593   if (dynamic_section == NULL)
15594     {
15595       /* No dynamic information available.  See if there is static GOT.  */
15596       sect = find_section (filedata, ".got");
15597       if (sect != NULL)
15598         {
15599           unsigned char *data_end;
15600           unsigned char *data;
15601           bfd_vma ent, end;
15602           int addr_size;
15603
15604           pltgot = sect->sh_addr;
15605
15606           ent = pltgot;
15607           addr_size = (is_32bit_elf ? 4 : 8);
15608           end = pltgot + sect->sh_size;
15609
15610           data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
15611                                              end - pltgot, 1,
15612                                              _("Global Offset Table data"));
15613           /* PR 12855: Null data is handled gracefully throughout.  */
15614           data_end = data + (end - pltgot);
15615
15616           printf (_("\nStatic GOT:\n"));
15617           printf (_(" Canonical gp value: "));
15618           print_vma (ent + 0x7ff0, LONG_HEX);
15619           printf ("\n\n");
15620
15621           /* In a dynamic binary GOT[0] is reserved for the dynamic
15622              loader to store the lazy resolver pointer, however in
15623              a static binary it may well have been omitted and GOT
15624              reduced to a table of addresses.
15625              PR 21344: Check for the entry being fully available
15626              before fetching it.  */
15627           if (data
15628               && data + ent - pltgot + addr_size <= data_end
15629               && byte_get (data + ent - pltgot, addr_size) == 0)
15630             {
15631               printf (_(" Reserved entries:\n"));
15632               printf (_("  %*s %10s %*s\n"),
15633                       addr_size * 2, _("Address"), _("Access"),
15634                       addr_size * 2, _("Value"));
15635               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15636               printf ("\n");
15637               if (ent == (bfd_vma) -1)
15638                 goto sgot_print_fail;
15639
15640               /* Check for the MSB of GOT[1] being set, identifying a
15641                  GNU object.  This entry will be used by some runtime
15642                  loaders, to store the module pointer.  Otherwise this
15643                  is an ordinary local entry.
15644                  PR 21344: Check for the entry being fully available
15645                  before fetching it.  */
15646               if (data
15647                   && data + ent - pltgot + addr_size <= data_end
15648                   && (byte_get (data + ent - pltgot, addr_size)
15649                       >> (addr_size * 8 - 1)) != 0)
15650                 {
15651                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15652                   printf ("\n");
15653                   if (ent == (bfd_vma) -1)
15654                     goto sgot_print_fail;
15655                 }
15656               printf ("\n");
15657             }
15658
15659           if (data != NULL && ent < end)
15660             {
15661               printf (_(" Local entries:\n"));
15662               printf ("  %*s %10s %*s\n",
15663                       addr_size * 2, _("Address"), _("Access"),
15664                       addr_size * 2, _("Value"));
15665               while (ent < end)
15666                 {
15667                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15668                   printf ("\n");
15669                   if (ent == (bfd_vma) -1)
15670                     goto sgot_print_fail;
15671                 }
15672               printf ("\n");
15673             }
15674
15675         sgot_print_fail:
15676           if (data)
15677             free (data);
15678         }
15679       return res;
15680     }
15681
15682   for (entry = dynamic_section;
15683        /* PR 17531 file: 012-50589-0.004.  */
15684        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15685        ++entry)
15686     switch (entry->d_tag)
15687       {
15688       case DT_MIPS_LIBLIST:
15689         liblist_offset
15690           = offset_from_vma (filedata, entry->d_un.d_val,
15691                              liblistno * sizeof (Elf32_External_Lib));
15692         break;
15693       case DT_MIPS_LIBLISTNO:
15694         liblistno = entry->d_un.d_val;
15695         break;
15696       case DT_MIPS_OPTIONS:
15697         options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
15698         break;
15699       case DT_MIPS_CONFLICT:
15700         conflicts_offset
15701           = offset_from_vma (filedata, entry->d_un.d_val,
15702                              conflictsno * sizeof (Elf32_External_Conflict));
15703         break;
15704       case DT_MIPS_CONFLICTNO:
15705         conflictsno = entry->d_un.d_val;
15706         break;
15707       case DT_PLTGOT:
15708         pltgot = entry->d_un.d_ptr;
15709         break;
15710       case DT_MIPS_LOCAL_GOTNO:
15711         local_gotno = entry->d_un.d_val;
15712         break;
15713       case DT_MIPS_GOTSYM:
15714         gotsym = entry->d_un.d_val;
15715         break;
15716       case DT_MIPS_SYMTABNO:
15717         symtabno = entry->d_un.d_val;
15718         break;
15719       case DT_MIPS_PLTGOT:
15720         mips_pltgot = entry->d_un.d_ptr;
15721         break;
15722       case DT_PLTREL:
15723         pltrel = entry->d_un.d_val;
15724         break;
15725       case DT_PLTRELSZ:
15726         pltrelsz = entry->d_un.d_val;
15727         break;
15728       case DT_JMPREL:
15729         jmprel = entry->d_un.d_ptr;
15730         break;
15731       default:
15732         break;
15733       }
15734
15735   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15736     {
15737       Elf32_External_Lib * elib;
15738       size_t cnt;
15739
15740       elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
15741                                               liblistno,
15742                                               sizeof (Elf32_External_Lib),
15743                                               _("liblist section data"));
15744       if (elib)
15745         {
15746           printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15747                             "\nSection '.liblist' contains %lu entries:\n",
15748                             (unsigned long) liblistno),
15749                   (unsigned long) liblistno);
15750           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
15751                  stdout);
15752
15753           for (cnt = 0; cnt < liblistno; ++cnt)
15754             {
15755               Elf32_Lib liblist;
15756               time_t atime;
15757               char timebuf[128];
15758               struct tm * tmp;
15759
15760               liblist.l_name = BYTE_GET (elib[cnt].l_name);
15761               atime = BYTE_GET (elib[cnt].l_time_stamp);
15762               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15763               liblist.l_version = BYTE_GET (elib[cnt].l_version);
15764               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15765
15766               tmp = gmtime (&atime);
15767               snprintf (timebuf, sizeof (timebuf),
15768                         "%04u-%02u-%02uT%02u:%02u:%02u",
15769                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15770                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15771
15772               printf ("%3lu: ", (unsigned long) cnt);
15773               if (VALID_DYNAMIC_NAME (liblist.l_name))
15774                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
15775               else
15776                 printf (_("<corrupt: %9ld>"), liblist.l_name);
15777               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
15778                       liblist.l_version);
15779
15780               if (liblist.l_flags == 0)
15781                 puts (_(" NONE"));
15782               else
15783                 {
15784                   static const struct
15785                   {
15786                     const char * name;
15787                     int bit;
15788                   }
15789                   l_flags_vals[] =
15790                   {
15791                     { " EXACT_MATCH", LL_EXACT_MATCH },
15792                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
15793                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
15794                     { " EXPORTS", LL_EXPORTS },
15795                     { " DELAY_LOAD", LL_DELAY_LOAD },
15796                     { " DELTA", LL_DELTA }
15797                   };
15798                   int flags = liblist.l_flags;
15799                   size_t fcnt;
15800
15801                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
15802                     if ((flags & l_flags_vals[fcnt].bit) != 0)
15803                       {
15804                         fputs (l_flags_vals[fcnt].name, stdout);
15805                         flags ^= l_flags_vals[fcnt].bit;
15806                       }
15807                   if (flags != 0)
15808                     printf (" %#x", (unsigned int) flags);
15809
15810                   puts ("");
15811                 }
15812             }
15813
15814           free (elib);
15815         }
15816       else
15817         res = FALSE;
15818     }
15819
15820   if (options_offset != 0)
15821     {
15822       Elf_External_Options * eopt;
15823       Elf_Internal_Options * iopt;
15824       Elf_Internal_Options * option;
15825       size_t offset;
15826       int cnt;
15827       sect = filedata->section_headers;
15828
15829       /* Find the section header so that we get the size.  */
15830       sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
15831       /* PR 17533 file: 012-277276-0.004.  */
15832       if (sect == NULL)
15833         {
15834           error (_("No MIPS_OPTIONS header found\n"));
15835           return FALSE;
15836         }
15837
15838       eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
15839                                                 sect->sh_size, _("options"));
15840       if (eopt)
15841         {
15842           iopt = (Elf_Internal_Options *)
15843               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
15844           if (iopt == NULL)
15845             {
15846               error (_("Out of memory allocating space for MIPS options\n"));
15847               return FALSE;
15848             }
15849
15850           offset = cnt = 0;
15851           option = iopt;
15852
15853           while (offset <= sect->sh_size - sizeof (* eopt))
15854             {
15855               Elf_External_Options * eoption;
15856
15857               eoption = (Elf_External_Options *) ((char *) eopt + offset);
15858
15859               option->kind = BYTE_GET (eoption->kind);
15860               option->size = BYTE_GET (eoption->size);
15861               option->section = BYTE_GET (eoption->section);
15862               option->info = BYTE_GET (eoption->info);
15863
15864               /* PR 17531: file: ffa0fa3b.  */
15865               if (option->size < sizeof (* eopt)
15866                   || offset + option->size > sect->sh_size)
15867                 {
15868                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
15869                   return FALSE;
15870                 }
15871               offset += option->size;
15872
15873               ++option;
15874               ++cnt;
15875             }
15876
15877           printf (ngettext ("\nSection '%s' contains %d entry:\n",
15878                             "\nSection '%s' contains %d entries:\n",
15879                             cnt),
15880                   printable_section_name (filedata, sect), cnt);
15881
15882           option = iopt;
15883           offset = 0;
15884
15885           while (cnt-- > 0)
15886             {
15887               size_t len;
15888
15889               switch (option->kind)
15890                 {
15891                 case ODK_NULL:
15892                   /* This shouldn't happen.  */
15893                   printf (" NULL       %d %lx", option->section, option->info);
15894                   break;
15895                 case ODK_REGINFO:
15896                   printf (" REGINFO    ");
15897                   if (filedata->file_header.e_machine == EM_MIPS)
15898                     {
15899                       /* 32bit form.  */
15900                       Elf32_External_RegInfo * ereg;
15901                       Elf32_RegInfo reginfo;
15902
15903                       ereg = (Elf32_External_RegInfo *) (option + 1);
15904                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15905                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15906                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15907                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15908                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15909                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
15910
15911                       printf ("GPR %08lx  GP 0x%lx\n",
15912                               reginfo.ri_gprmask,
15913                               (unsigned long) reginfo.ri_gp_value);
15914                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15915                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15916                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15917                     }
15918                   else
15919                     {
15920                       /* 64 bit form.  */
15921                       Elf64_External_RegInfo * ereg;
15922                       Elf64_Internal_RegInfo reginfo;
15923
15924                       ereg = (Elf64_External_RegInfo *) (option + 1);
15925                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
15926                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15927                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15928                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15929                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15930                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
15931
15932                       printf ("GPR %08lx  GP 0x",
15933                               reginfo.ri_gprmask);
15934                       printf_vma (reginfo.ri_gp_value);
15935                       printf ("\n");
15936
15937                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15938                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15939                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15940                     }
15941                   ++option;
15942                   continue;
15943                 case ODK_EXCEPTIONS:
15944                   fputs (" EXCEPTIONS fpe_min(", stdout);
15945                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
15946                   fputs (") fpe_max(", stdout);
15947                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
15948                   fputs (")", stdout);
15949
15950                   if (option->info & OEX_PAGE0)
15951                     fputs (" PAGE0", stdout);
15952                   if (option->info & OEX_SMM)
15953                     fputs (" SMM", stdout);
15954                   if (option->info & OEX_FPDBUG)
15955                     fputs (" FPDBUG", stdout);
15956                   if (option->info & OEX_DISMISS)
15957                     fputs (" DISMISS", stdout);
15958                   break;
15959                 case ODK_PAD:
15960                   fputs (" PAD       ", stdout);
15961                   if (option->info & OPAD_PREFIX)
15962                     fputs (" PREFIX", stdout);
15963                   if (option->info & OPAD_POSTFIX)
15964                     fputs (" POSTFIX", stdout);
15965                   if (option->info & OPAD_SYMBOL)
15966                     fputs (" SYMBOL", stdout);
15967                   break;
15968                 case ODK_HWPATCH:
15969                   fputs (" HWPATCH   ", stdout);
15970                   if (option->info & OHW_R4KEOP)
15971                     fputs (" R4KEOP", stdout);
15972                   if (option->info & OHW_R8KPFETCH)
15973                     fputs (" R8KPFETCH", stdout);
15974                   if (option->info & OHW_R5KEOP)
15975                     fputs (" R5KEOP", stdout);
15976                   if (option->info & OHW_R5KCVTL)
15977                     fputs (" R5KCVTL", stdout);
15978                   break;
15979                 case ODK_FILL:
15980                   fputs (" FILL       ", stdout);
15981                   /* XXX Print content of info word?  */
15982                   break;
15983                 case ODK_TAGS:
15984                   fputs (" TAGS       ", stdout);
15985                   /* XXX Print content of info word?  */
15986                   break;
15987                 case ODK_HWAND:
15988                   fputs (" HWAND     ", stdout);
15989                   if (option->info & OHWA0_R4KEOP_CHECKED)
15990                     fputs (" R4KEOP_CHECKED", stdout);
15991                   if (option->info & OHWA0_R4KEOP_CLEAN)
15992                     fputs (" R4KEOP_CLEAN", stdout);
15993                   break;
15994                 case ODK_HWOR:
15995                   fputs (" HWOR      ", stdout);
15996                   if (option->info & OHWA0_R4KEOP_CHECKED)
15997                     fputs (" R4KEOP_CHECKED", stdout);
15998                   if (option->info & OHWA0_R4KEOP_CLEAN)
15999                     fputs (" R4KEOP_CLEAN", stdout);
16000                   break;
16001                 case ODK_GP_GROUP:
16002                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
16003                           option->info & OGP_GROUP,
16004                           (option->info & OGP_SELF) >> 16);
16005                   break;
16006                 case ODK_IDENT:
16007                   printf (" IDENT     %#06lx  self-contained %#06lx",
16008                           option->info & OGP_GROUP,
16009                           (option->info & OGP_SELF) >> 16);
16010                   break;
16011                 default:
16012                   /* This shouldn't happen.  */
16013                   printf (" %3d ???     %d %lx",
16014                           option->kind, option->section, option->info);
16015                   break;
16016                 }
16017
16018               len = sizeof (* eopt);
16019               while (len < option->size)
16020                 {
16021                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
16022
16023                   if (ISPRINT (datum))
16024                     printf ("%c", datum);
16025                   else
16026                     printf ("\\%03o", datum);
16027                   len ++;
16028                 }
16029               fputs ("\n", stdout);
16030
16031               offset += option->size;
16032               ++option;
16033             }
16034
16035           free (eopt);
16036         }
16037       else
16038         res = FALSE;
16039     }
16040
16041   if (conflicts_offset != 0 && conflictsno != 0)
16042     {
16043       Elf32_Conflict * iconf;
16044       size_t cnt;
16045
16046       if (dynamic_symbols == NULL)
16047         {
16048           error (_("conflict list found without a dynamic symbol table\n"));
16049           return FALSE;
16050         }
16051
16052       /* PR 21345 - print a slightly more helpful error message
16053          if we are sure that the cmalloc will fail.  */
16054       if (conflictsno * sizeof (* iconf) > filedata->file_size)
16055         {
16056           error (_("Overlarge number of conflicts detected: %lx\n"),
16057                  (long) conflictsno);
16058           return FALSE;
16059         }
16060
16061       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16062       if (iconf == NULL)
16063         {
16064           error (_("Out of memory allocating space for dynamic conflicts\n"));
16065           return FALSE;
16066         }
16067
16068       if (is_32bit_elf)
16069         {
16070           Elf32_External_Conflict * econf32;
16071
16072           econf32 = (Elf32_External_Conflict *)
16073               get_data (NULL, filedata, conflicts_offset, conflictsno,
16074                         sizeof (* econf32), _("conflict"));
16075           if (!econf32)
16076             return FALSE;
16077
16078           for (cnt = 0; cnt < conflictsno; ++cnt)
16079             iconf[cnt] = BYTE_GET (econf32[cnt]);
16080
16081           free (econf32);
16082         }
16083       else
16084         {
16085           Elf64_External_Conflict * econf64;
16086
16087           econf64 = (Elf64_External_Conflict *)
16088               get_data (NULL, filedata, conflicts_offset, conflictsno,
16089                         sizeof (* econf64), _("conflict"));
16090           if (!econf64)
16091             return FALSE;
16092
16093           for (cnt = 0; cnt < conflictsno; ++cnt)
16094             iconf[cnt] = BYTE_GET (econf64[cnt]);
16095
16096           free (econf64);
16097         }
16098
16099       printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16100                         "\nSection '.conflict' contains %lu entries:\n",
16101                         (unsigned long) conflictsno),
16102               (unsigned long) conflictsno);
16103       puts (_("  Num:    Index       Value  Name"));
16104
16105       for (cnt = 0; cnt < conflictsno; ++cnt)
16106         {
16107           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
16108
16109           if (iconf[cnt] >= num_dynamic_syms)
16110             printf (_("<corrupt symbol index>"));
16111           else
16112             {
16113               Elf_Internal_Sym * psym;
16114
16115               psym = & dynamic_symbols[iconf[cnt]];
16116               print_vma (psym->st_value, FULL_HEX);
16117               putchar (' ');
16118               if (VALID_DYNAMIC_NAME (psym->st_name))
16119                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16120               else
16121                 printf (_("<corrupt: %14ld>"), psym->st_name);
16122             }
16123           putchar ('\n');
16124         }
16125
16126       free (iconf);
16127     }
16128
16129   if (pltgot != 0 && local_gotno != 0)
16130     {
16131       bfd_vma ent, local_end, global_end;
16132       size_t i, offset;
16133       unsigned char * data;
16134       unsigned char * data_end;
16135       int addr_size;
16136
16137       ent = pltgot;
16138       addr_size = (is_32bit_elf ? 4 : 8);
16139       local_end = pltgot + local_gotno * addr_size;
16140
16141       /* PR binutils/17533 file: 012-111227-0.004  */
16142       if (symtabno < gotsym)
16143         {
16144           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16145                  (unsigned long) gotsym, (unsigned long) symtabno);
16146           return FALSE;
16147         }
16148
16149       global_end = local_end + (symtabno - gotsym) * addr_size;
16150       /* PR 17531: file: 54c91a34.  */
16151       if (global_end < local_end)
16152         {
16153           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
16154           return FALSE;
16155         }
16156
16157       offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
16158       data = (unsigned char *) get_data (NULL, filedata, offset,
16159                                          global_end - pltgot, 1,
16160                                          _("Global Offset Table data"));
16161       /* PR 12855: Null data is handled gracefully throughout.  */
16162       data_end = data + (global_end - pltgot);
16163
16164       printf (_("\nPrimary GOT:\n"));
16165       printf (_(" Canonical gp value: "));
16166       print_vma (pltgot + 0x7ff0, LONG_HEX);
16167       printf ("\n\n");
16168
16169       printf (_(" Reserved entries:\n"));
16170       printf (_("  %*s %10s %*s Purpose\n"),
16171               addr_size * 2, _("Address"), _("Access"),
16172               addr_size * 2, _("Initial"));
16173       ent = print_mips_got_entry (data, pltgot, ent, data_end);
16174       printf (_(" Lazy resolver\n"));
16175       if (ent == (bfd_vma) -1)
16176         goto got_print_fail;
16177
16178       /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16179          This entry will be used by some runtime loaders, to store the
16180          module pointer.  Otherwise this is an ordinary local entry.
16181          PR 21344: Check for the entry being fully available before
16182          fetching it.  */
16183       if (data
16184           && data + ent - pltgot + addr_size <= data_end
16185           && (byte_get (data + ent - pltgot, addr_size)
16186               >> (addr_size * 8 - 1)) != 0)
16187         {
16188           ent = print_mips_got_entry (data, pltgot, ent, data_end);
16189           printf (_(" Module pointer (GNU extension)\n"));
16190           if (ent == (bfd_vma) -1)
16191             goto got_print_fail;
16192         }
16193       printf ("\n");
16194
16195       if (data != NULL && ent < local_end)
16196         {
16197           printf (_(" Local entries:\n"));
16198           printf ("  %*s %10s %*s\n",
16199                   addr_size * 2, _("Address"), _("Access"),
16200                   addr_size * 2, _("Initial"));
16201           while (ent < local_end)
16202             {
16203               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16204               printf ("\n");
16205               if (ent == (bfd_vma) -1)
16206                 goto got_print_fail;
16207             }
16208           printf ("\n");
16209         }
16210
16211       if (data != NULL && gotsym < symtabno)
16212         {
16213           int sym_width;
16214
16215           printf (_(" Global entries:\n"));
16216           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
16217                   addr_size * 2, _("Address"),
16218                   _("Access"),
16219                   addr_size * 2, _("Initial"),
16220                   addr_size * 2, _("Sym.Val."),
16221                   _("Type"),
16222                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
16223                   _("Ndx"), _("Name"));
16224
16225           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
16226
16227           for (i = gotsym; i < symtabno; i++)
16228             {
16229               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16230               printf (" ");
16231
16232               if (dynamic_symbols == NULL)
16233                 printf (_("<no dynamic symbols>"));
16234               else if (i < num_dynamic_syms)
16235                 {
16236                   Elf_Internal_Sym * psym = dynamic_symbols + i;
16237
16238                   print_vma (psym->st_value, LONG_HEX);
16239                   printf (" %-7s %3s ",
16240                           get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16241                           get_symbol_index_type (filedata, psym->st_shndx));
16242
16243                   if (VALID_DYNAMIC_NAME (psym->st_name))
16244                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16245                   else
16246                     printf (_("<corrupt: %14ld>"), psym->st_name);
16247                 }
16248               else
16249                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16250                         (unsigned long) i);
16251
16252               printf ("\n");
16253               if (ent == (bfd_vma) -1)
16254                 break;
16255             }
16256           printf ("\n");
16257         }
16258
16259     got_print_fail:
16260       if (data)
16261         free (data);
16262     }
16263
16264   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
16265     {
16266       bfd_vma ent, end;
16267       size_t offset, rel_offset;
16268       unsigned long count, i;
16269       unsigned char * data;
16270       int addr_size, sym_width;
16271       Elf_Internal_Rela * rels;
16272
16273       rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
16274       if (pltrel == DT_RELA)
16275         {
16276           if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16277             return FALSE;
16278         }
16279       else
16280         {
16281           if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16282             return FALSE;
16283         }
16284
16285       ent = mips_pltgot;
16286       addr_size = (is_32bit_elf ? 4 : 8);
16287       end = mips_pltgot + (2 + count) * addr_size;
16288
16289       offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
16290       data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
16291                                          1, _("Procedure Linkage Table data"));
16292       if (data == NULL)
16293         return FALSE;
16294
16295       printf ("\nPLT GOT:\n\n");
16296       printf (_(" Reserved entries:\n"));
16297       printf (_("  %*s %*s Purpose\n"),
16298               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
16299       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16300       printf (_(" PLT lazy resolver\n"));
16301       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16302       printf (_(" Module pointer\n"));
16303       printf ("\n");
16304
16305       printf (_(" Entries:\n"));
16306       printf ("  %*s %*s %*s %-7s %3s %s\n",
16307               addr_size * 2, _("Address"),
16308               addr_size * 2, _("Initial"),
16309               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16310       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
16311       for (i = 0; i < count; i++)
16312         {
16313           unsigned long idx = get_reloc_symindex (rels[i].r_info);
16314
16315           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16316           printf (" ");
16317
16318           if (idx >= num_dynamic_syms)
16319             printf (_("<corrupt symbol index: %lu>"), idx);
16320           else
16321             {
16322               Elf_Internal_Sym * psym = dynamic_symbols + idx;
16323
16324               print_vma (psym->st_value, LONG_HEX);
16325               printf (" %-7s %3s ",
16326                       get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16327                       get_symbol_index_type (filedata, psym->st_shndx));
16328               if (VALID_DYNAMIC_NAME (psym->st_name))
16329                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16330               else
16331                 printf (_("<corrupt: %14ld>"), psym->st_name);
16332             }
16333           printf ("\n");
16334         }
16335       printf ("\n");
16336
16337       if (data)
16338         free (data);
16339       free (rels);
16340     }
16341
16342   return res;
16343 }
16344
16345 static bfd_boolean
16346 process_nds32_specific (Filedata * filedata)
16347 {
16348   Elf_Internal_Shdr *sect = NULL;
16349
16350   sect = find_section (filedata, ".nds32_e_flags");
16351   if (sect != NULL)
16352     {
16353       unsigned int *flag;
16354
16355       printf ("\nNDS32 elf flags section:\n");
16356       flag = get_data (NULL, filedata, sect->sh_offset, 1,
16357                        sect->sh_size, _("NDS32 elf flags section"));
16358
16359       if (! flag)
16360         return FALSE;
16361
16362       switch ((*flag) & 0x3)
16363         {
16364         case 0:
16365           printf ("(VEC_SIZE):\tNo entry.\n");
16366           break;
16367         case 1:
16368           printf ("(VEC_SIZE):\t4 bytes\n");
16369           break;
16370         case 2:
16371           printf ("(VEC_SIZE):\t16 bytes\n");
16372           break;
16373         case 3:
16374           printf ("(VEC_SIZE):\treserved\n");
16375           break;
16376         }
16377     }
16378
16379   return TRUE;
16380 }
16381
16382 static bfd_boolean
16383 process_gnu_liblist (Filedata * filedata)
16384 {
16385   Elf_Internal_Shdr * section;
16386   Elf_Internal_Shdr * string_sec;
16387   Elf32_External_Lib * elib;
16388   char * strtab;
16389   size_t strtab_size;
16390   size_t cnt;
16391   unsigned long num_liblist;
16392   unsigned i;
16393   bfd_boolean res = TRUE;
16394
16395   if (! do_arch)
16396     return TRUE;
16397
16398   for (i = 0, section = filedata->section_headers;
16399        i < filedata->file_header.e_shnum;
16400        i++, section++)
16401     {
16402       switch (section->sh_type)
16403         {
16404         case SHT_GNU_LIBLIST:
16405           if (section->sh_link >= filedata->file_header.e_shnum)
16406             break;
16407
16408           elib = (Elf32_External_Lib *)
16409               get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
16410                         _("liblist section data"));
16411
16412           if (elib == NULL)
16413             {
16414               res = FALSE;
16415               break;
16416             }
16417
16418           string_sec = filedata->section_headers + section->sh_link;
16419           strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
16420                                       string_sec->sh_size,
16421                                       _("liblist string table"));
16422           if (strtab == NULL
16423               || section->sh_entsize != sizeof (Elf32_External_Lib))
16424             {
16425               free (elib);
16426               free (strtab);
16427               res = FALSE;
16428               break;
16429             }
16430           strtab_size = string_sec->sh_size;
16431
16432           num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
16433           printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16434                             "\nLibrary list section '%s' contains %lu entries:\n",
16435                             num_liblist),
16436                   printable_section_name (filedata, section),
16437                   num_liblist);
16438
16439           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
16440
16441           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16442                ++cnt)
16443             {
16444               Elf32_Lib liblist;
16445               time_t atime;
16446               char timebuf[128];
16447               struct tm * tmp;
16448
16449               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16450               atime = BYTE_GET (elib[cnt].l_time_stamp);
16451               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16452               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16453               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16454
16455               tmp = gmtime (&atime);
16456               snprintf (timebuf, sizeof (timebuf),
16457                         "%04u-%02u-%02uT%02u:%02u:%02u",
16458                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16459                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16460
16461               printf ("%3lu: ", (unsigned long) cnt);
16462               if (do_wide)
16463                 printf ("%-20s", liblist.l_name < strtab_size
16464                         ? strtab + liblist.l_name : _("<corrupt>"));
16465               else
16466                 printf ("%-20.20s", liblist.l_name < strtab_size
16467                         ? strtab + liblist.l_name : _("<corrupt>"));
16468               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16469                       liblist.l_version, liblist.l_flags);
16470             }
16471
16472           free (elib);
16473           free (strtab);
16474         }
16475     }
16476
16477   return res;
16478 }
16479
16480 static const char *
16481 get_note_type (Filedata * filedata, unsigned e_type)
16482 {
16483   static char buff[64];
16484
16485   if (filedata->file_header.e_type == ET_CORE)
16486     switch (e_type)
16487       {
16488       case NT_AUXV:
16489         return _("NT_AUXV (auxiliary vector)");
16490       case NT_PRSTATUS:
16491         return _("NT_PRSTATUS (prstatus structure)");
16492       case NT_FPREGSET:
16493         return _("NT_FPREGSET (floating point registers)");
16494       case NT_PRPSINFO:
16495         return _("NT_PRPSINFO (prpsinfo structure)");
16496       case NT_TASKSTRUCT:
16497         return _("NT_TASKSTRUCT (task structure)");
16498       case NT_PRXFPREG:
16499         return _("NT_PRXFPREG (user_xfpregs structure)");
16500       case NT_PPC_VMX:
16501         return _("NT_PPC_VMX (ppc Altivec registers)");
16502       case NT_PPC_VSX:
16503         return _("NT_PPC_VSX (ppc VSX registers)");
16504       case NT_PPC_TAR:
16505         return _("NT_PPC_TAR (ppc TAR register)");
16506       case NT_PPC_PPR:
16507         return _("NT_PPC_PPR (ppc PPR register)");
16508       case NT_PPC_DSCR:
16509         return _("NT_PPC_DSCR (ppc DSCR register)");
16510       case NT_PPC_EBB:
16511         return _("NT_PPC_EBB (ppc EBB registers)");
16512       case NT_PPC_PMU:
16513         return _("NT_PPC_PMU (ppc PMU registers)");
16514       case NT_PPC_TM_CGPR:
16515         return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16516       case NT_PPC_TM_CFPR:
16517         return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16518       case NT_PPC_TM_CVMX:
16519         return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16520       case NT_PPC_TM_CVSX:
16521         return _("NT_PPC_TM_VSX (ppc checkpointed VSX registers)");
16522       case NT_PPC_TM_SPR:
16523         return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16524       case NT_PPC_TM_CTAR:
16525         return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16526       case NT_PPC_TM_CPPR:
16527         return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16528       case NT_PPC_TM_CDSCR:
16529         return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16530       case NT_386_TLS:
16531         return _("NT_386_TLS (x86 TLS information)");
16532       case NT_386_IOPERM:
16533         return _("NT_386_IOPERM (x86 I/O permissions)");
16534       case NT_X86_XSTATE:
16535         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16536       case NT_S390_HIGH_GPRS:
16537         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16538       case NT_S390_TIMER:
16539         return _("NT_S390_TIMER (s390 timer register)");
16540       case NT_S390_TODCMP:
16541         return _("NT_S390_TODCMP (s390 TOD comparator register)");
16542       case NT_S390_TODPREG:
16543         return _("NT_S390_TODPREG (s390 TOD programmable register)");
16544       case NT_S390_CTRS:
16545         return _("NT_S390_CTRS (s390 control registers)");
16546       case NT_S390_PREFIX:
16547         return _("NT_S390_PREFIX (s390 prefix register)");
16548       case NT_S390_LAST_BREAK:
16549         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16550       case NT_S390_SYSTEM_CALL:
16551         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16552       case NT_S390_TDB:
16553         return _("NT_S390_TDB (s390 transaction diagnostic block)");
16554       case NT_S390_VXRS_LOW:
16555         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16556       case NT_S390_VXRS_HIGH:
16557         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16558       case NT_S390_GS_CB:
16559         return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16560       case NT_S390_GS_BC:
16561         return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16562       case NT_ARM_VFP:
16563         return _("NT_ARM_VFP (arm VFP registers)");
16564       case NT_ARM_TLS:
16565         return _("NT_ARM_TLS (AArch TLS registers)");
16566       case NT_ARM_HW_BREAK:
16567         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16568       case NT_ARM_HW_WATCH:
16569         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16570       case NT_PSTATUS:
16571         return _("NT_PSTATUS (pstatus structure)");
16572       case NT_FPREGS:
16573         return _("NT_FPREGS (floating point registers)");
16574       case NT_PSINFO:
16575         return _("NT_PSINFO (psinfo structure)");
16576       case NT_LWPSTATUS:
16577         return _("NT_LWPSTATUS (lwpstatus_t structure)");
16578       case NT_LWPSINFO:
16579         return _("NT_LWPSINFO (lwpsinfo_t structure)");
16580       case NT_WIN32PSTATUS:
16581         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16582       case NT_SIGINFO:
16583         return _("NT_SIGINFO (siginfo_t data)");
16584       case NT_FILE:
16585         return _("NT_FILE (mapped files)");
16586       default:
16587         break;
16588       }
16589   else
16590     switch (e_type)
16591       {
16592       case NT_VERSION:
16593         return _("NT_VERSION (version)");
16594       case NT_ARCH:
16595         return _("NT_ARCH (architecture)");
16596       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16597         return _("OPEN");
16598       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16599         return _("func");
16600       default:
16601         break;
16602       }
16603
16604   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16605   return buff;
16606 }
16607
16608 static bfd_boolean
16609 print_core_note (Elf_Internal_Note *pnote)
16610 {
16611   unsigned int addr_size = is_32bit_elf ? 4 : 8;
16612   bfd_vma count, page_size;
16613   unsigned char *descdata, *filenames, *descend;
16614
16615   if (pnote->type != NT_FILE)
16616     {
16617       if (do_wide)
16618         printf ("\n");
16619       return TRUE;
16620     }
16621
16622 #ifndef BFD64
16623   if (!is_32bit_elf)
16624     {
16625       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
16626       /* Still "successful".  */
16627       return TRUE;
16628     }
16629 #endif
16630
16631   if (pnote->descsz < 2 * addr_size)
16632     {
16633       error (_("    Malformed note - too short for header\n"));
16634       return FALSE;
16635     }
16636
16637   descdata = (unsigned char *) pnote->descdata;
16638   descend = descdata + pnote->descsz;
16639
16640   if (descdata[pnote->descsz - 1] != '\0')
16641     {
16642       error (_("    Malformed note - does not end with \\0\n"));
16643       return FALSE;
16644     }
16645
16646   count = byte_get (descdata, addr_size);
16647   descdata += addr_size;
16648
16649   page_size = byte_get (descdata, addr_size);
16650   descdata += addr_size;
16651
16652   if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
16653       || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16654     {
16655       error (_("    Malformed note - too short for supplied file count\n"));
16656       return FALSE;
16657     }
16658
16659   printf (_("    Page size: "));
16660   print_vma (page_size, DEC);
16661   printf ("\n");
16662
16663   printf (_("    %*s%*s%*s\n"),
16664           (int) (2 + 2 * addr_size), _("Start"),
16665           (int) (4 + 2 * addr_size), _("End"),
16666           (int) (4 + 2 * addr_size), _("Page Offset"));
16667   filenames = descdata + count * 3 * addr_size;
16668   while (count-- > 0)
16669     {
16670       bfd_vma start, end, file_ofs;
16671
16672       if (filenames == descend)
16673         {
16674           error (_("    Malformed note - filenames end too early\n"));
16675           return FALSE;
16676         }
16677
16678       start = byte_get (descdata, addr_size);
16679       descdata += addr_size;
16680       end = byte_get (descdata, addr_size);
16681       descdata += addr_size;
16682       file_ofs = byte_get (descdata, addr_size);
16683       descdata += addr_size;
16684
16685       printf ("    ");
16686       print_vma (start, FULL_HEX);
16687       printf ("  ");
16688       print_vma (end, FULL_HEX);
16689       printf ("  ");
16690       print_vma (file_ofs, FULL_HEX);
16691       printf ("\n        %s\n", filenames);
16692
16693       filenames += 1 + strlen ((char *) filenames);
16694     }
16695
16696   return TRUE;
16697 }
16698
16699 static const char *
16700 get_gnu_elf_note_type (unsigned e_type)
16701 {
16702   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
16703   switch (e_type)
16704     {
16705     case NT_GNU_ABI_TAG:
16706       return _("NT_GNU_ABI_TAG (ABI version tag)");
16707     case NT_GNU_HWCAP:
16708       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16709     case NT_GNU_BUILD_ID:
16710       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16711     case NT_GNU_GOLD_VERSION:
16712       return _("NT_GNU_GOLD_VERSION (gold version)");
16713     case NT_GNU_PROPERTY_TYPE_0:
16714       return _("NT_GNU_PROPERTY_TYPE_0");
16715     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16716       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16717     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16718       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16719     default:
16720       {
16721         static char buff[64];
16722
16723         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16724         return buff;
16725       }
16726     }
16727 }
16728
16729 static void
16730 decode_x86_isa (unsigned int bitmask)
16731 {
16732   while (bitmask)
16733     {
16734       unsigned int bit = bitmask & (- bitmask);
16735
16736       bitmask &= ~ bit;
16737       switch (bit)
16738         {
16739         case GNU_PROPERTY_X86_ISA_1_486: printf ("i486"); break;
16740         case GNU_PROPERTY_X86_ISA_1_586: printf ("586"); break;
16741         case GNU_PROPERTY_X86_ISA_1_686: printf ("686"); break;
16742         case GNU_PROPERTY_X86_ISA_1_SSE: printf ("SSE"); break;
16743         case GNU_PROPERTY_X86_ISA_1_SSE2: printf ("SSE2"); break;
16744         case GNU_PROPERTY_X86_ISA_1_SSE3: printf ("SSE3"); break;
16745         case GNU_PROPERTY_X86_ISA_1_SSSE3: printf ("SSSE3"); break;
16746         case GNU_PROPERTY_X86_ISA_1_SSE4_1: printf ("SSE4_1"); break;
16747         case GNU_PROPERTY_X86_ISA_1_SSE4_2: printf ("SSE4_2"); break;
16748         case GNU_PROPERTY_X86_ISA_1_AVX: printf ("AVX"); break;
16749         case GNU_PROPERTY_X86_ISA_1_AVX2: printf ("AVX2"); break;
16750         case GNU_PROPERTY_X86_ISA_1_AVX512F: printf ("AVX512F"); break;
16751         case GNU_PROPERTY_X86_ISA_1_AVX512CD: printf ("AVX512CD"); break;
16752         case GNU_PROPERTY_X86_ISA_1_AVX512ER: printf ("AVX512ER"); break;
16753         case GNU_PROPERTY_X86_ISA_1_AVX512PF: printf ("AVX512PF"); break;
16754         case GNU_PROPERTY_X86_ISA_1_AVX512VL: printf ("AVX512VL"); break;
16755         case GNU_PROPERTY_X86_ISA_1_AVX512DQ: printf ("AVX512DQ"); break;
16756         case GNU_PROPERTY_X86_ISA_1_AVX512BW: printf ("AVX512BW"); break;
16757         default: printf (_("<unknown: %x>"), bit); break;
16758         }
16759       if (bitmask)
16760         printf (", ");
16761     }
16762 }
16763
16764 static void
16765 decode_x86_feature (unsigned int type, unsigned int bitmask)
16766 {
16767   while (bitmask)
16768     {
16769       unsigned int bit = bitmask & (- bitmask);
16770
16771       bitmask &= ~ bit;
16772       switch (bit)
16773         {
16774         case GNU_PROPERTY_X86_FEATURE_1_IBT:
16775           switch (type)
16776             {
16777             case GNU_PROPERTY_X86_FEATURE_1_AND:
16778               printf ("IBT");
16779               break;
16780             default:
16781               /* This should never happen.  */
16782               abort ();
16783             }
16784           break;
16785         case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
16786           switch (type)
16787             {
16788             case GNU_PROPERTY_X86_FEATURE_1_AND:
16789               printf ("SHSTK");
16790               break;
16791             default:
16792               /* This should never happen.  */
16793               abort ();
16794             }
16795           break;
16796         default:
16797           printf (_("<unknown: %x>"), bit);
16798           break;
16799         }
16800       if (bitmask)
16801         printf (", ");
16802     }
16803 }
16804
16805 static void
16806 print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
16807 {
16808   unsigned char * ptr = (unsigned char *) pnote->descdata;
16809   unsigned char * ptr_end = ptr + pnote->descsz;
16810   unsigned int    size = is_32bit_elf ? 4 : 8;
16811
16812   printf (_("      Properties: "));
16813
16814   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
16815     {
16816       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
16817       return;
16818     }
16819
16820   while (ptr < ptr_end)
16821     {
16822       unsigned int j;
16823       unsigned int type;
16824       unsigned int datasz;
16825
16826       if ((size_t) (ptr_end - ptr) < 8)
16827         {
16828           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
16829           break;
16830         }
16831
16832       type = byte_get (ptr, 4);
16833       datasz = byte_get (ptr + 4, 4);
16834
16835       ptr += 8;
16836
16837       if (datasz > (size_t) (ptr_end - ptr))
16838         {
16839           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16840                   type, datasz);
16841           break;
16842         }
16843
16844       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
16845         {
16846           if (filedata->file_header.e_machine == EM_X86_64
16847               || filedata->file_header.e_machine == EM_IAMCU
16848               || filedata->file_header.e_machine == EM_386)
16849             {
16850               switch (type)
16851                 {
16852                 case GNU_PROPERTY_X86_ISA_1_USED:
16853                   printf ("x86 ISA used: ");
16854                   if (datasz != 4)
16855                     printf (_("<corrupt length: %#x> "), datasz);
16856                   else
16857                     decode_x86_isa (byte_get (ptr, 4));
16858                   goto next;
16859
16860                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
16861                   printf ("x86 ISA needed: ");
16862                   if (datasz != 4)
16863                     printf (_("<corrupt length: %#x> "), datasz);
16864                   else
16865                     decode_x86_isa (byte_get (ptr, 4));
16866                   goto next;
16867
16868                 case GNU_PROPERTY_X86_FEATURE_1_AND:
16869                   printf ("x86 feature: ");
16870                   if (datasz != 4)
16871                     printf (_("<corrupt length: %#x> "), datasz);
16872                   else
16873                     decode_x86_feature (type, byte_get (ptr, 4));
16874                   goto next;
16875
16876                 default:
16877                   break;
16878                 }
16879             }
16880         }
16881       else
16882         {
16883           switch (type)
16884             {
16885             case GNU_PROPERTY_STACK_SIZE:
16886               printf (_("stack size: "));
16887               if (datasz != size)
16888                 printf (_("<corrupt length: %#x> "), datasz);
16889               else
16890                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
16891               goto next;
16892
16893             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
16894               printf ("no copy on protected ");
16895               if (datasz)
16896                 printf (_("<corrupt length: %#x> "), datasz);
16897               goto next;
16898
16899             default:
16900               break;
16901             }
16902         }
16903
16904       if (type < GNU_PROPERTY_LOPROC)
16905         printf (_("<unknown type %#x data: "), type);
16906       else if (type < GNU_PROPERTY_LOUSER)
16907         printf (_("<procesor-specific type %#x data: "), type);
16908       else
16909         printf (_("<application-specific type %#x data: "), type);
16910       for (j = 0; j < datasz; ++j)
16911         printf ("%02x ", ptr[j] & 0xff);
16912       printf (">");
16913
16914 next:
16915       ptr += ((datasz + (size - 1)) & ~ (size - 1));
16916       if (ptr == ptr_end)
16917         break;
16918
16919       if (do_wide)
16920         printf (", ");
16921       else
16922         printf ("\n\t");
16923     }
16924
16925   printf ("\n");
16926 }
16927
16928 static bfd_boolean
16929 print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
16930 {
16931   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
16932   switch (pnote->type)
16933     {
16934     case NT_GNU_BUILD_ID:
16935       {
16936         unsigned long i;
16937
16938         printf (_("    Build ID: "));
16939         for (i = 0; i < pnote->descsz; ++i)
16940           printf ("%02x", pnote->descdata[i] & 0xff);
16941         printf ("\n");
16942       }
16943       break;
16944
16945     case NT_GNU_ABI_TAG:
16946       {
16947         unsigned long os, major, minor, subminor;
16948         const char *osname;
16949
16950         /* PR 17531: file: 030-599401-0.004.  */
16951         if (pnote->descsz < 16)
16952           {
16953             printf (_("    <corrupt GNU_ABI_TAG>\n"));
16954             break;
16955           }
16956
16957         os = byte_get ((unsigned char *) pnote->descdata, 4);
16958         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16959         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
16960         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
16961
16962         switch (os)
16963           {
16964           case GNU_ABI_TAG_LINUX:
16965             osname = "Linux";
16966             break;
16967           case GNU_ABI_TAG_HURD:
16968             osname = "Hurd";
16969             break;
16970           case GNU_ABI_TAG_SOLARIS:
16971             osname = "Solaris";
16972             break;
16973           case GNU_ABI_TAG_FREEBSD:
16974             osname = "FreeBSD";
16975             break;
16976           case GNU_ABI_TAG_NETBSD:
16977             osname = "NetBSD";
16978             break;
16979           case GNU_ABI_TAG_SYLLABLE:
16980             osname = "Syllable";
16981             break;
16982           case GNU_ABI_TAG_NACL:
16983             osname = "NaCl";
16984             break;
16985           default:
16986             osname = "Unknown";
16987             break;
16988           }
16989
16990         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
16991                 major, minor, subminor);
16992       }
16993       break;
16994
16995     case NT_GNU_GOLD_VERSION:
16996       {
16997         unsigned long i;
16998
16999         printf (_("    Version: "));
17000         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
17001           printf ("%c", pnote->descdata[i]);
17002         printf ("\n");
17003       }
17004       break;
17005
17006     case NT_GNU_HWCAP:
17007       {
17008         unsigned long num_entries, mask;
17009
17010         /* Hardware capabilities information.  Word 0 is the number of entries.
17011            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
17012            is a series of entries, where each entry is a single byte followed
17013            by a nul terminated string.  The byte gives the bit number to test
17014            if enabled in the bitmask.  */
17015         printf (_("      Hardware Capabilities: "));
17016         if (pnote->descsz < 8)
17017           {
17018             error (_("<corrupt GNU_HWCAP>\n"));
17019             return FALSE;
17020           }
17021         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
17022         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17023         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
17024         /* FIXME: Add code to display the entries... */
17025       }
17026       break;
17027
17028     case NT_GNU_PROPERTY_TYPE_0:
17029       print_gnu_property_note (filedata, pnote);
17030       break;
17031
17032     default:
17033       /* Handle unrecognised types.  An error message should have already been
17034          created by get_gnu_elf_note_type(), so all that we need to do is to
17035          display the data.  */
17036       {
17037         unsigned long i;
17038
17039         printf (_("    Description data: "));
17040         for (i = 0; i < pnote->descsz; ++i)
17041           printf ("%02x ", pnote->descdata[i] & 0xff);
17042         printf ("\n");
17043       }
17044       break;
17045     }
17046
17047   return TRUE;
17048 }
17049
17050 static const char *
17051 get_v850_elf_note_type (enum v850_notes n_type)
17052 {
17053   static char buff[64];
17054
17055   switch (n_type)
17056     {
17057     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
17058     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
17059     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
17060     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
17061     case V850_NOTE_CACHE_INFO: return _("Use of cache");
17062     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
17063     default:
17064       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
17065       return buff;
17066     }
17067 }
17068
17069 static bfd_boolean
17070 print_v850_note (Elf_Internal_Note * pnote)
17071 {
17072   unsigned int val;
17073
17074   if (pnote->descsz != 4)
17075     return FALSE;
17076
17077   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
17078
17079   if (val == 0)
17080     {
17081       printf (_("not set\n"));
17082       return TRUE;
17083     }
17084
17085   switch (pnote->type)
17086     {
17087     case V850_NOTE_ALIGNMENT:
17088       switch (val)
17089         {
17090         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
17091         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
17092         }
17093       break;
17094
17095     case V850_NOTE_DATA_SIZE:
17096       switch (val)
17097         {
17098         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
17099         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
17100         }
17101       break;
17102
17103     case V850_NOTE_FPU_INFO:
17104       switch (val)
17105         {
17106         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
17107         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
17108         }
17109       break;
17110
17111     case V850_NOTE_MMU_INFO:
17112     case V850_NOTE_CACHE_INFO:
17113     case V850_NOTE_SIMD_INFO:
17114       if (val == EF_RH850_SIMD)
17115         {
17116           printf (_("yes\n"));
17117           return TRUE;
17118         }
17119       break;
17120
17121     default:
17122       /* An 'unknown note type' message will already have been displayed.  */
17123       break;
17124     }
17125
17126   printf (_("unknown value: %x\n"), val);
17127   return FALSE;
17128 }
17129
17130 static bfd_boolean
17131 process_netbsd_elf_note (Elf_Internal_Note * pnote)
17132 {
17133   unsigned int version;
17134
17135   switch (pnote->type)
17136     {
17137     case NT_NETBSD_IDENT:
17138       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
17139       if ((version / 10000) % 100)
17140         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
17141                 version, version / 100000000, (version / 1000000) % 100,
17142                 (version / 10000) % 100 > 26 ? "Z" : "",
17143                 'A' + (version / 10000) % 26);
17144       else
17145         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
17146                 version, version / 100000000, (version / 1000000) % 100,
17147                 (version / 100) % 100);
17148       return TRUE;
17149
17150     case NT_NETBSD_MARCH:
17151       printf ("  NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
17152               pnote->descdata);
17153       return TRUE;
17154
17155     default:
17156       printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
17157               pnote->type);
17158       return FALSE;
17159     }
17160 }
17161
17162 static const char *
17163 get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17164 {
17165   switch (e_type)
17166     {
17167     case NT_FREEBSD_THRMISC:
17168       return _("NT_THRMISC (thrmisc structure)");
17169     case NT_FREEBSD_PROCSTAT_PROC:
17170       return _("NT_PROCSTAT_PROC (proc data)");
17171     case NT_FREEBSD_PROCSTAT_FILES:
17172       return _("NT_PROCSTAT_FILES (files data)");
17173     case NT_FREEBSD_PROCSTAT_VMMAP:
17174       return _("NT_PROCSTAT_VMMAP (vmmap data)");
17175     case NT_FREEBSD_PROCSTAT_GROUPS:
17176       return _("NT_PROCSTAT_GROUPS (groups data)");
17177     case NT_FREEBSD_PROCSTAT_UMASK:
17178       return _("NT_PROCSTAT_UMASK (umask data)");
17179     case NT_FREEBSD_PROCSTAT_RLIMIT:
17180       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17181     case NT_FREEBSD_PROCSTAT_OSREL:
17182       return _("NT_PROCSTAT_OSREL (osreldate data)");
17183     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
17184       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17185     case NT_FREEBSD_PROCSTAT_AUXV:
17186       return _("NT_PROCSTAT_AUXV (auxv data)");
17187     case NT_FREEBSD_PTLWPINFO:
17188       return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17189     }
17190   return get_note_type (filedata, e_type);
17191 }
17192
17193 static const char *
17194 get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17195 {
17196   static char buff[64];
17197
17198   if (e_type == NT_NETBSDCORE_PROCINFO)
17199     return _("NetBSD procinfo structure");
17200
17201   /* As of Jan 2002 there are no other machine-independent notes
17202      defined for NetBSD core files.  If the note type is less
17203      than the start of the machine-dependent note types, we don't
17204      understand it.  */
17205
17206   if (e_type < NT_NETBSDCORE_FIRSTMACH)
17207     {
17208       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17209       return buff;
17210     }
17211
17212   switch (filedata->file_header.e_machine)
17213     {
17214     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17215        and PT_GETFPREGS == mach+2.  */
17216
17217     case EM_OLD_ALPHA:
17218     case EM_ALPHA:
17219     case EM_SPARC:
17220     case EM_SPARC32PLUS:
17221     case EM_SPARCV9:
17222       switch (e_type)
17223         {
17224         case NT_NETBSDCORE_FIRSTMACH + 0:
17225           return _("PT_GETREGS (reg structure)");
17226         case NT_NETBSDCORE_FIRSTMACH + 2:
17227           return _("PT_GETFPREGS (fpreg structure)");
17228         default:
17229           break;
17230         }
17231       break;
17232
17233     /* On all other arch's, PT_GETREGS == mach+1 and
17234        PT_GETFPREGS == mach+3.  */
17235     default:
17236       switch (e_type)
17237         {
17238         case NT_NETBSDCORE_FIRSTMACH + 1:
17239           return _("PT_GETREGS (reg structure)");
17240         case NT_NETBSDCORE_FIRSTMACH + 3:
17241           return _("PT_GETFPREGS (fpreg structure)");
17242         default:
17243           break;
17244         }
17245     }
17246
17247   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
17248             e_type - NT_NETBSDCORE_FIRSTMACH);
17249   return buff;
17250 }
17251
17252 static const char *
17253 get_stapsdt_note_type (unsigned e_type)
17254 {
17255   static char buff[64];
17256
17257   switch (e_type)
17258     {
17259     case NT_STAPSDT:
17260       return _("NT_STAPSDT (SystemTap probe descriptors)");
17261
17262     default:
17263       break;
17264     }
17265
17266   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17267   return buff;
17268 }
17269
17270 static bfd_boolean
17271 print_stapsdt_note (Elf_Internal_Note *pnote)
17272 {
17273   int addr_size = is_32bit_elf ? 4 : 8;
17274   char *data = pnote->descdata;
17275   char *data_end = pnote->descdata + pnote->descsz;
17276   bfd_vma pc, base_addr, semaphore;
17277   char *provider, *probe, *arg_fmt;
17278
17279   pc = byte_get ((unsigned char *) data, addr_size);
17280   data += addr_size;
17281   base_addr = byte_get ((unsigned char *) data, addr_size);
17282   data += addr_size;
17283   semaphore = byte_get ((unsigned char *) data, addr_size);
17284   data += addr_size;
17285
17286   provider = data;
17287   data += strlen (data) + 1;
17288   probe = data;
17289   data += strlen (data) + 1;
17290   arg_fmt = data;
17291   data += strlen (data) + 1;
17292
17293   printf (_("    Provider: %s\n"), provider);
17294   printf (_("    Name: %s\n"), probe);
17295   printf (_("    Location: "));
17296   print_vma (pc, FULL_HEX);
17297   printf (_(", Base: "));
17298   print_vma (base_addr, FULL_HEX);
17299   printf (_(", Semaphore: "));
17300   print_vma (semaphore, FULL_HEX);
17301   printf ("\n");
17302   printf (_("    Arguments: %s\n"), arg_fmt);
17303
17304   return data == data_end;
17305 }
17306
17307 static const char *
17308 get_ia64_vms_note_type (unsigned e_type)
17309 {
17310   static char buff[64];
17311
17312   switch (e_type)
17313     {
17314     case NT_VMS_MHD:
17315       return _("NT_VMS_MHD (module header)");
17316     case NT_VMS_LNM:
17317       return _("NT_VMS_LNM (language name)");
17318     case NT_VMS_SRC:
17319       return _("NT_VMS_SRC (source files)");
17320     case NT_VMS_TITLE:
17321       return "NT_VMS_TITLE";
17322     case NT_VMS_EIDC:
17323       return _("NT_VMS_EIDC (consistency check)");
17324     case NT_VMS_FPMODE:
17325       return _("NT_VMS_FPMODE (FP mode)");
17326     case NT_VMS_LINKTIME:
17327       return "NT_VMS_LINKTIME";
17328     case NT_VMS_IMGNAM:
17329       return _("NT_VMS_IMGNAM (image name)");
17330     case NT_VMS_IMGID:
17331       return _("NT_VMS_IMGID (image id)");
17332     case NT_VMS_LINKID:
17333       return _("NT_VMS_LINKID (link id)");
17334     case NT_VMS_IMGBID:
17335       return _("NT_VMS_IMGBID (build id)");
17336     case NT_VMS_GSTNAM:
17337       return _("NT_VMS_GSTNAM (sym table name)");
17338     case NT_VMS_ORIG_DYN:
17339       return "NT_VMS_ORIG_DYN";
17340     case NT_VMS_PATCHTIME:
17341       return "NT_VMS_PATCHTIME";
17342     default:
17343       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17344       return buff;
17345     }
17346 }
17347
17348 static bfd_boolean
17349 print_ia64_vms_note (Elf_Internal_Note * pnote)
17350 {
17351   switch (pnote->type)
17352     {
17353     case NT_VMS_MHD:
17354       if (pnote->descsz > 36)
17355         {
17356           size_t l = strlen (pnote->descdata + 34);
17357           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
17358           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
17359           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
17360           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
17361         }
17362       else
17363         printf (_("    Invalid size\n"));
17364       break;
17365     case NT_VMS_LNM:
17366       printf (_("   Language: %s\n"), pnote->descdata);
17367       break;
17368 #ifdef BFD64
17369     case NT_VMS_FPMODE:
17370       printf (_("   Floating Point mode: "));
17371       printf ("0x%016" BFD_VMA_FMT "x\n",
17372               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
17373       break;
17374     case NT_VMS_LINKTIME:
17375       printf (_("   Link 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_PATCHTIME:
17381       printf (_("   Patch time: "));
17382       print_vms_time
17383         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17384       printf ("\n");
17385       break;
17386     case NT_VMS_ORIG_DYN:
17387       printf (_("   Major id: %u,  minor id: %u\n"),
17388               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
17389               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
17390       printf (_("   Last modified  : "));
17391       print_vms_time
17392         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
17393       printf (_("\n   Link flags  : "));
17394       printf ("0x%016" BFD_VMA_FMT "x\n",
17395               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
17396       printf (_("   Header flags: 0x%08x\n"),
17397               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
17398       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
17399       break;
17400 #endif
17401     case NT_VMS_IMGNAM:
17402       printf (_("    Image name: %s\n"), pnote->descdata);
17403       break;
17404     case NT_VMS_GSTNAM:
17405       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
17406       break;
17407     case NT_VMS_IMGID:
17408       printf (_("    Image id: %s\n"), pnote->descdata);
17409       break;
17410     case NT_VMS_LINKID:
17411       printf (_("    Linker id: %s\n"), pnote->descdata);
17412       break;
17413     default:
17414       return FALSE;
17415     }
17416   return TRUE;
17417 }
17418
17419 /* Find the symbol associated with a build attribute that is attached
17420    to address OFFSET.  If PNAME is non-NULL then store the name of
17421    the symbol (if found) in the provided pointer,  Returns NULL if a
17422    symbol could not be found.  */
17423
17424 static Elf_Internal_Sym *
17425 get_symbol_for_build_attribute (Filedata *       filedata,
17426                                 unsigned long    offset,
17427                                 bfd_boolean      is_open_attr,
17428                                 const char **    pname)
17429 {
17430   static Filedata *         saved_filedata = NULL;
17431   static char *             strtab;
17432   static unsigned long      strtablen;
17433   static Elf_Internal_Sym * symtab;
17434   static unsigned long      nsyms;
17435   Elf_Internal_Sym *        saved_sym = NULL;
17436   Elf_Internal_Sym *        sym;
17437
17438   if (filedata->section_headers != NULL
17439       && (saved_filedata == NULL || filedata != saved_filedata))
17440     {
17441       Elf_Internal_Shdr * symsec;
17442
17443       /* Load the symbol and string sections.  */
17444       for (symsec = filedata->section_headers;
17445            symsec < filedata->section_headers + filedata->file_header.e_shnum;
17446            symsec ++)
17447         {
17448           if (symsec->sh_type == SHT_SYMTAB)
17449             {
17450               symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
17451
17452               if (symsec->sh_link < filedata->file_header.e_shnum)
17453                 {
17454                   Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
17455
17456                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
17457                                               1, strtab_sec->sh_size,
17458                                               _("string table"));
17459                   strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
17460                 }
17461             }
17462         }
17463       saved_filedata = filedata;
17464     }
17465
17466   if (symtab == NULL || strtab == NULL)
17467     return NULL;
17468
17469   /* Find a symbol whose value matches offset.  */
17470   for (sym = symtab; sym < symtab + nsyms; sym ++)
17471     if (sym->st_value == offset)
17472       {
17473         if (sym->st_name >= strtablen)
17474           /* Huh ?  This should not happen.  */
17475           continue;
17476
17477         if (strtab[sym->st_name] == 0)
17478           continue;
17479
17480         if (is_open_attr)
17481           {
17482             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17483                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
17484                FUNC symbols entirely.  */
17485             switch (ELF_ST_TYPE (sym->st_info))
17486               {
17487               case STT_OBJECT:
17488               case STT_FILE:
17489                 saved_sym = sym;
17490                 if (sym->st_size)
17491                   {
17492                     /* If the symbol has a size associated
17493                        with it then we can stop searching.  */
17494                     sym = symtab + nsyms;
17495                   }
17496                 continue;
17497
17498               case STT_FUNC:
17499                 /* Ignore function symbols.  */
17500                 continue;
17501
17502               default:
17503                 break;
17504               }
17505
17506             switch (ELF_ST_BIND (sym->st_info))
17507               {
17508               case STB_GLOBAL:
17509                 if (saved_sym == NULL
17510                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
17511                   saved_sym = sym;
17512                 break;
17513
17514               case STB_LOCAL:
17515                 if (saved_sym == NULL)
17516                   saved_sym = sym;
17517                 break;
17518
17519               default:
17520                 break;
17521               }
17522           }
17523         else
17524           {
17525             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
17526               continue;
17527
17528             saved_sym = sym;
17529             break;
17530           }
17531       }
17532
17533   if (saved_sym && pname)
17534     * pname = strtab + saved_sym->st_name;
17535
17536   return saved_sym;
17537 }
17538
17539 static bfd_boolean
17540 print_gnu_build_attribute_description (Elf_Internal_Note *  pnote,
17541                                        Filedata *           filedata)
17542 {
17543   static unsigned long  global_offset = 0;
17544   static unsigned long  global_end = 0;
17545   static unsigned long  func_offset = 0;
17546   static unsigned long  func_end = 0;
17547
17548   Elf_Internal_Sym *    sym;
17549   const char *          name;
17550   unsigned long         start;
17551   unsigned long         end;
17552   bfd_boolean           is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
17553
17554   switch (pnote->descsz)
17555     {
17556     case 0:
17557       /* A zero-length description means that the range of
17558          the previous note of the same type should be used.  */
17559       if (is_open_attr)
17560         {
17561           if (global_end > global_offset)
17562             printf (_("    Applies to region from %#lx to %#lx\n"),
17563                     global_offset, global_end);
17564           else
17565             printf (_("    Applies to region from %#lx\n"), global_offset);
17566         }
17567       else
17568         {
17569           if (func_end > func_offset)
17570             printf (_("    Applies to region from %#lx to %#lx\n"), func_offset, func_end);
17571           else
17572             printf (_("    Applies to region from %#lx\n"), func_offset);
17573         }
17574       return TRUE;
17575
17576     case 4:
17577       start = byte_get ((unsigned char *) pnote->descdata, 4);
17578       end = 0;
17579       break;
17580
17581     case 8:
17582       if (is_32bit_elf)
17583         {
17584           /* FIXME: We should check that version 3+ notes are being used here...  */
17585           start = byte_get ((unsigned char *) pnote->descdata, 4);
17586           end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17587         }
17588       else
17589         {
17590           start = byte_get ((unsigned char *) pnote->descdata, 8);
17591           end = 0;
17592         }
17593       break;
17594
17595     case 16:
17596       start = byte_get ((unsigned char *) pnote->descdata, 8);
17597       end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
17598       break;
17599
17600     default:
17601       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
17602       printf (_("    <invalid descsz>"));
17603       return FALSE;
17604     }
17605
17606   name = NULL;
17607   sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
17608
17609   if (end == 0 && sym != NULL && sym->st_size > 0)
17610     end = start + sym->st_size;
17611
17612   if (is_open_attr)
17613     {
17614       /* FIXME: Need to properly allow for section alignment.  16 is just the alignment used on x86_64.  */
17615       if (global_end > 0 && start > BFD_ALIGN (global_end, 16))
17616         warn (_("Gap in build notes detected from %#lx to %#lx\n"),
17617               global_end + 1, start - 1);
17618
17619       printf (_("    Applies to region from %#lx"), start);
17620       global_offset = start;
17621
17622       if (end)
17623         {
17624           printf (_(" to %#lx"), end);
17625           global_end = end;
17626         }
17627     }
17628   else
17629     {
17630       printf (_("    Applies to region from %#lx"), start);
17631       func_offset = start;
17632
17633       if (end)
17634         {
17635           printf (_(" to %#lx"), end);
17636           func_end = end;
17637         }
17638     }
17639
17640   if (sym && name)
17641     printf (_(" (%s)"), name);
17642
17643   printf ("\n");
17644   return TRUE;
17645 }
17646
17647 static bfd_boolean
17648 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
17649 {
17650   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
17651   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
17652   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
17653   char         name_type;
17654   char         name_attribute;
17655   const char * expected_types;
17656   const char * name = pnote->namedata;
17657   const char * text;
17658   signed int   left;
17659
17660   if (name == NULL || pnote->namesz < 2)
17661     {
17662       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17663       print_symbol (-20, _("  <corrupt name>"));
17664       return FALSE;
17665     }
17666
17667   if (do_wide)
17668     left = 28;
17669   else
17670     left = 20;
17671
17672   /* Version 2 of the spec adds a "GA" prefix to the name field.  */
17673   if (name[0] == 'G' && name[1] == 'A')
17674     {
17675       if (pnote->namesz < 4)
17676         {
17677           error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17678           print_symbol (-20, _("  <corrupt name>"));
17679           return FALSE;
17680         }
17681
17682       printf ("GA");
17683       name += 2;
17684       left -= 2;
17685     }
17686
17687   switch ((name_type = * name))
17688     {
17689     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17690     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17691     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17692     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17693       printf ("%c", * name);
17694       left --;
17695       break;
17696     default:
17697       error (_("unrecognised attribute type in name field: %d\n"), name_type);
17698       print_symbol (-20, _("<unknown name type>"));
17699       return FALSE;
17700     }
17701
17702   ++ name;
17703   text = NULL;
17704
17705   switch ((name_attribute = * name))
17706     {
17707     case GNU_BUILD_ATTRIBUTE_VERSION:
17708       text = _("<version>");
17709       expected_types = string_expected;
17710       ++ name;
17711       break;
17712     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17713       text = _("<stack prot>");
17714       expected_types = "!+*";
17715       ++ name;
17716       break;
17717     case GNU_BUILD_ATTRIBUTE_RELRO:
17718       text = _("<relro>");
17719       expected_types = bool_expected;
17720       ++ name;
17721       break;
17722     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
17723       text = _("<stack size>");
17724       expected_types = number_expected;
17725       ++ name;
17726       break;
17727     case GNU_BUILD_ATTRIBUTE_TOOL:
17728       text = _("<tool>");
17729       expected_types = string_expected;
17730       ++ name;
17731       break;
17732     case GNU_BUILD_ATTRIBUTE_ABI:
17733       text = _("<ABI>");
17734       expected_types = "$*";
17735       ++ name;
17736       break;
17737     case GNU_BUILD_ATTRIBUTE_PIC:
17738       text = _("<PIC>");
17739       expected_types = number_expected;
17740       ++ name;
17741       break;
17742     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
17743       text = _("<short enum>");
17744       expected_types = bool_expected;
17745       ++ name;
17746       break;
17747     default:
17748       if (ISPRINT (* name))
17749         {
17750           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
17751
17752           if (len > left && ! do_wide)
17753             len = left;
17754           printf ("%.*s:", len, name);
17755           left -= len;
17756           name += len;
17757         }
17758       else
17759         {
17760           static char tmpbuf [128];
17761
17762           error (_("unrecognised byte in name field: %d\n"), * name);
17763           sprintf (tmpbuf, _("<unknown:_%d>"), * name);
17764           text = tmpbuf;
17765           name ++;
17766         }
17767       expected_types = "*$!+";
17768       break;
17769     }
17770
17771   if (text)
17772     left -= printf ("%s", text);
17773
17774   if (strchr (expected_types, name_type) == NULL)
17775     warn (_("attribute does not have an expected type (%c)\n"), name_type);
17776
17777   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
17778     {
17779       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17780              (unsigned long) pnote->namesz,
17781              (long) (name - pnote->namedata));
17782       return FALSE;
17783     }
17784
17785   if (left < 1 && ! do_wide)
17786     return TRUE;
17787
17788   switch (name_type)
17789     {
17790     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17791       {
17792         unsigned int        bytes;
17793         unsigned long long  val = 0;
17794         unsigned int        shift = 0;
17795         char *              decoded = NULL;
17796
17797         bytes = pnote->namesz - (name - pnote->namedata);
17798         if (bytes > 0)
17799           /* The -1 is because the name field is always 0 terminated, and we
17800              want to be able to ensure that the shift in the while loop below
17801              will not overflow.  */
17802           -- bytes;
17803
17804         if (bytes > sizeof (val))
17805           {
17806             error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17807                    bytes);
17808             bytes = sizeof (val);
17809           }
17810         /* We do not bother to warn if bytes == 0 as this can
17811            happen with some early versions of the gcc plugin.  */
17812
17813         while (bytes --)
17814           {
17815             unsigned long byte = (* name ++) & 0xff;
17816
17817             val |= byte << shift;
17818             shift += 8;
17819           }
17820
17821         switch (name_attribute)
17822           {
17823           case GNU_BUILD_ATTRIBUTE_PIC:
17824             switch (val)
17825               {
17826               case 0: decoded = "static"; break;
17827               case 1: decoded = "pic"; break;
17828               case 2: decoded = "PIC"; break;
17829               case 3: decoded = "pie"; break;
17830               case 4: decoded = "PIE"; break;
17831               default: break;
17832               }
17833             break;
17834           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17835             switch (val)
17836               {
17837                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
17838               case 0: decoded = "off"; break;
17839               case 1: decoded = "on"; break;
17840               case 2: decoded = "all"; break;
17841               case 3: decoded = "strong"; break;
17842               case 4: decoded = "explicit"; break;
17843               default: break;
17844               }
17845             break;
17846           default:
17847             break;
17848           }
17849
17850         if (decoded != NULL)
17851           {
17852             print_symbol (-left, decoded);
17853             left = 0;
17854           }
17855         else if (val == 0)
17856           {
17857             printf ("0x0");
17858             left -= 3;
17859           }
17860         else
17861           {
17862             if (do_wide)
17863               left -= printf ("0x%llx", val);
17864             else
17865               left -= printf ("0x%-.*llx", left, val);
17866           }
17867       }
17868       break;
17869     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17870       left -= print_symbol (- left, name);
17871       break;
17872     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17873       left -= print_symbol (- left, "true");
17874       break;
17875     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17876       left -= print_symbol (- left, "false");
17877       break;
17878     }
17879
17880   if (do_wide && left > 0)
17881     printf ("%-*s", left, " ");
17882
17883   return TRUE;
17884 }
17885
17886 /* Note that by the ELF standard, the name field is already null byte
17887    terminated, and namesz includes the terminating null byte.
17888    I.E. the value of namesz for the name "FSF" is 4.
17889
17890    If the value of namesz is zero, there is no name present.  */
17891
17892 static bfd_boolean
17893 process_note (Elf_Internal_Note *  pnote,
17894               Filedata *           filedata)
17895 {
17896   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
17897   const char * nt;
17898
17899   if (pnote->namesz == 0)
17900     /* If there is no note name, then use the default set of
17901        note type strings.  */
17902     nt = get_note_type (filedata, pnote->type);
17903
17904   else if (const_strneq (pnote->namedata, "GNU"))
17905     /* GNU-specific object file notes.  */
17906     nt = get_gnu_elf_note_type (pnote->type);
17907
17908   else if (const_strneq (pnote->namedata, "FreeBSD"))
17909     /* FreeBSD-specific core file notes.  */
17910     nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
17911
17912   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
17913     /* NetBSD-specific core file notes.  */
17914     nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
17915
17916   else if (const_strneq (pnote->namedata, "NetBSD"))
17917     /* NetBSD-specific core file notes.  */
17918     return process_netbsd_elf_note (pnote);
17919
17920   else if (strneq (pnote->namedata, "SPU/", 4))
17921     {
17922       /* SPU-specific core file notes.  */
17923       nt = pnote->namedata + 4;
17924       name = "SPU";
17925     }
17926
17927   else if (const_strneq (pnote->namedata, "IPF/VMS"))
17928     /* VMS/ia64-specific file notes.  */
17929     nt = get_ia64_vms_note_type (pnote->type);
17930
17931   else if (const_strneq (pnote->namedata, "stapsdt"))
17932     nt = get_stapsdt_note_type (pnote->type);
17933
17934   else
17935     /* Don't recognize this note name; just use the default set of
17936        note type strings.  */
17937     nt = get_note_type (filedata, pnote->type);
17938
17939   printf ("  ");
17940
17941   if (((const_strneq (pnote->namedata, "GA")
17942         && strchr ("*$!+", pnote->namedata[2]) != NULL)
17943        || strchr ("*$!+", pnote->namedata[0]) != NULL)
17944       && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17945           || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
17946     print_gnu_build_attribute_name (pnote);
17947   else
17948     print_symbol (-20, name);
17949
17950   if (do_wide)
17951     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
17952   else
17953     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
17954
17955   if (const_strneq (pnote->namedata, "IPF/VMS"))
17956     return print_ia64_vms_note (pnote);
17957   else if (const_strneq (pnote->namedata, "GNU"))
17958     return print_gnu_note (filedata, pnote);
17959   else if (const_strneq (pnote->namedata, "stapsdt"))
17960     return print_stapsdt_note (pnote);
17961   else if (const_strneq (pnote->namedata, "CORE"))
17962     return print_core_note (pnote);
17963   else if (((const_strneq (pnote->namedata, "GA")
17964              && strchr ("*$!+", pnote->namedata[2]) != NULL)
17965             || strchr ("*$!+", pnote->namedata[0]) != NULL)
17966            && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17967                || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
17968     return print_gnu_build_attribute_description (pnote, filedata);
17969
17970   if (pnote->descsz)
17971     {
17972       unsigned long i;
17973
17974       printf (_("   description data: "));
17975       for (i = 0; i < pnote->descsz; i++)
17976         printf ("%02x ", pnote->descdata[i]);
17977       if (!do_wide)
17978         printf ("\n");
17979     }
17980
17981   if (do_wide)
17982     printf ("\n");
17983
17984   return TRUE;
17985 }
17986
17987 static bfd_boolean
17988 process_notes_at (Filedata *           filedata,
17989                   Elf_Internal_Shdr *  section,
17990                   bfd_vma              offset,
17991                   bfd_vma              length,
17992                   bfd_vma              align)
17993 {
17994   Elf_External_Note * pnotes;
17995   Elf_External_Note * external;
17996   char *              end;
17997   bfd_boolean         res = TRUE;
17998
17999   if (length <= 0)
18000     return FALSE;
18001
18002   if (section)
18003     {
18004       pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
18005       if (pnotes)
18006         {
18007           if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
18008             return FALSE;
18009         }
18010     }
18011   else
18012     pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18013                                              _("notes"));
18014
18015   if (pnotes == NULL)
18016     return FALSE;
18017
18018   external = pnotes;
18019
18020   if (section)
18021     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
18022   else
18023     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18024             (unsigned long) offset, (unsigned long) length);
18025
18026   /* NB: Some note sections may have alignment value of 0 or 1.  gABI
18027      specifies that notes should be aligned to 4 bytes in 32-bit
18028      objects and to 8 bytes in 64-bit objects.  As a Linux extension,
18029      we also support 4 byte alignment in 64-bit objects.  If section
18030      alignment is less than 4, we treate alignment as 4 bytes.   */
18031   if (align < 4)
18032     align = 4;
18033   else if (align != 4 && align != 8)
18034     {
18035       warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18036             (long) align);
18037       return FALSE;
18038     }
18039
18040   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18041
18042   end = (char *) pnotes + length;
18043   while ((char *) external < end)
18044     {
18045       Elf_Internal_Note inote;
18046       size_t min_notesz;
18047       char * next;
18048       char * temp = NULL;
18049       size_t data_remaining = end - (char *) external;
18050
18051       if (!is_ia64_vms (filedata))
18052         {
18053           /* PR binutils/15191
18054              Make sure that there is enough data to read.  */
18055           min_notesz = offsetof (Elf_External_Note, name);
18056           if (data_remaining < min_notesz)
18057             {
18058               warn (ngettext ("Corrupt note: only %ld byte remains, "
18059                               "not enough for a full note\n",
18060                               "Corrupt note: only %ld bytes remain, "
18061                               "not enough for a full note\n",
18062                               data_remaining),
18063                     (long) data_remaining);
18064               break;
18065             }
18066           data_remaining -= min_notesz;
18067
18068           inote.type     = BYTE_GET (external->type);
18069           inote.namesz   = BYTE_GET (external->namesz);
18070           inote.namedata = external->name;
18071           inote.descsz   = BYTE_GET (external->descsz);
18072           inote.descdata = ((char *) external
18073                             + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
18074           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18075           next = ((char *) external
18076                   + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
18077         }
18078       else
18079         {
18080           Elf64_External_VMS_Note *vms_external;
18081
18082           /* PR binutils/15191
18083              Make sure that there is enough data to read.  */
18084           min_notesz = offsetof (Elf64_External_VMS_Note, name);
18085           if (data_remaining < min_notesz)
18086             {
18087               warn (ngettext ("Corrupt note: only %ld byte remains, "
18088                               "not enough for a full note\n",
18089                               "Corrupt note: only %ld bytes remain, "
18090                               "not enough for a full note\n",
18091                               data_remaining),
18092                     (long) data_remaining);
18093               break;
18094             }
18095           data_remaining -= min_notesz;
18096
18097           vms_external = (Elf64_External_VMS_Note *) external;
18098           inote.type     = BYTE_GET (vms_external->type);
18099           inote.namesz   = BYTE_GET (vms_external->namesz);
18100           inote.namedata = vms_external->name;
18101           inote.descsz   = BYTE_GET (vms_external->descsz);
18102           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
18103           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18104           next = inote.descdata + align_power (inote.descsz, 3);
18105         }
18106
18107       /* PR 17531: file: 3443835e.  */
18108       /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
18109       if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
18110           || (size_t) (inote.descdata - inote.namedata) > data_remaining
18111           || (size_t) (next - inote.descdata) < inote.descsz
18112           || ((size_t) (next - inote.descdata)
18113               > data_remaining - (size_t) (inote.descdata - inote.namedata)))
18114         {
18115           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18116                 (unsigned long) ((char *) external - (char *) pnotes));
18117           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18118                 inote.type, inote.namesz, inote.descsz, (int) align);
18119           break;
18120         }
18121
18122       external = (Elf_External_Note *) next;
18123
18124       /* Verify that name is null terminated.  It appears that at least
18125          one version of Linux (RedHat 6.0) generates corefiles that don't
18126          comply with the ELF spec by failing to include the null byte in
18127          namesz.  */
18128       if (inote.namedata[inote.namesz - 1] != '\0')
18129         {
18130           if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
18131             {
18132               temp = (char *) malloc (inote.namesz + 1);
18133               if (temp == NULL)
18134                 {
18135                   error (_("Out of memory allocating space for inote name\n"));
18136                   res = FALSE;
18137                   break;
18138                 }
18139
18140               memcpy (temp, inote.namedata, inote.namesz);
18141               inote.namedata = temp;
18142             }
18143           inote.namedata[inote.namesz] = 0;
18144         }
18145
18146       if (! process_note (& inote, filedata))
18147         res = FALSE;
18148
18149       if (temp != NULL)
18150         {
18151           free (temp);
18152           temp = NULL;
18153         }
18154     }
18155
18156   free (pnotes);
18157
18158   return res;
18159 }
18160
18161 static bfd_boolean
18162 process_corefile_note_segments (Filedata * filedata)
18163 {
18164   Elf_Internal_Phdr * segment;
18165   unsigned int i;
18166   bfd_boolean res = TRUE;
18167
18168   if (! get_program_headers (filedata))
18169     return TRUE;
18170
18171   for (i = 0, segment = filedata->program_headers;
18172        i < filedata->file_header.e_phnum;
18173        i++, segment++)
18174     {
18175       if (segment->p_type == PT_NOTE)
18176         if (! process_notes_at (filedata, NULL,
18177                                 (bfd_vma) segment->p_offset,
18178                                 (bfd_vma) segment->p_filesz,
18179                                 (bfd_vma) segment->p_align))
18180           res = FALSE;
18181     }
18182
18183   return res;
18184 }
18185
18186 static bfd_boolean
18187 process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
18188 {
18189   Elf_External_Note * pnotes;
18190   Elf_External_Note * external;
18191   char * end;
18192   bfd_boolean res = TRUE;
18193
18194   if (length <= 0)
18195     return FALSE;
18196
18197   pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18198                                            _("v850 notes"));
18199   if (pnotes == NULL)
18200     return FALSE;
18201
18202   external = pnotes;
18203   end = (char*) pnotes + length;
18204
18205   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18206           (unsigned long) offset, (unsigned long) length);
18207
18208   while ((char *) external + sizeof (Elf_External_Note) < end)
18209     {
18210       Elf_External_Note * next;
18211       Elf_Internal_Note inote;
18212
18213       inote.type     = BYTE_GET (external->type);
18214       inote.namesz   = BYTE_GET (external->namesz);
18215       inote.namedata = external->name;
18216       inote.descsz   = BYTE_GET (external->descsz);
18217       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
18218       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18219
18220       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
18221         {
18222           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
18223           inote.descdata = inote.namedata;
18224           inote.namesz   = 0;
18225         }
18226
18227       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
18228
18229       if (   ((char *) next > end)
18230           || ((char *) next <  (char *) pnotes))
18231         {
18232           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18233                 (unsigned long) ((char *) external - (char *) pnotes));
18234           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18235                 inote.type, inote.namesz, inote.descsz);
18236           break;
18237         }
18238
18239       external = next;
18240
18241       /* Prevent out-of-bounds indexing.  */
18242       if (   inote.namedata + inote.namesz > end
18243           || inote.namedata + inote.namesz < inote.namedata)
18244         {
18245           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18246                 (unsigned long) ((char *) external - (char *) pnotes));
18247           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18248                 inote.type, inote.namesz, inote.descsz);
18249           break;
18250         }
18251
18252       printf ("  %s: ", get_v850_elf_note_type (inote.type));
18253
18254       if (! print_v850_note (& inote))
18255         {
18256           res = FALSE;
18257           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18258                   inote.namesz, inote.descsz);
18259         }
18260     }
18261
18262   free (pnotes);
18263
18264   return res;
18265 }
18266
18267 static bfd_boolean
18268 process_note_sections (Filedata * filedata)
18269 {
18270   Elf_Internal_Shdr * section;
18271   unsigned long i;
18272   unsigned int n = 0;
18273   bfd_boolean res = TRUE;
18274
18275   for (i = 0, section = filedata->section_headers;
18276        i < filedata->file_header.e_shnum && section != NULL;
18277        i++, section++)
18278     {
18279       if (section->sh_type == SHT_NOTE)
18280         {
18281           if (! process_notes_at (filedata, section,
18282                                   (bfd_vma) section->sh_offset,
18283                                   (bfd_vma) section->sh_size,
18284                                   (bfd_vma) section->sh_addralign))
18285             res = FALSE;
18286           n++;
18287         }
18288
18289       if ((   filedata->file_header.e_machine == EM_V800
18290            || filedata->file_header.e_machine == EM_V850
18291            || filedata->file_header.e_machine == EM_CYGNUS_V850)
18292           && section->sh_type == SHT_RENESAS_INFO)
18293         {
18294           if (! process_v850_notes (filedata,
18295                                     (bfd_vma) section->sh_offset,
18296                                     (bfd_vma) section->sh_size))
18297             res = FALSE;
18298           n++;
18299         }
18300     }
18301
18302   if (n == 0)
18303     /* Try processing NOTE segments instead.  */
18304     return process_corefile_note_segments (filedata);
18305
18306   return res;
18307 }
18308
18309 static bfd_boolean
18310 process_notes (Filedata * filedata)
18311 {
18312   /* If we have not been asked to display the notes then do nothing.  */
18313   if (! do_notes)
18314     return TRUE;
18315
18316   if (filedata->file_header.e_type != ET_CORE)
18317     return process_note_sections (filedata);
18318
18319   /* No program headers means no NOTE segment.  */
18320   if (filedata->file_header.e_phnum > 0)
18321     return process_corefile_note_segments (filedata);
18322
18323   printf (_("No note segments present in the core file.\n"));
18324   return TRUE;
18325 }
18326
18327 static unsigned char *
18328 display_public_gnu_attributes (unsigned char * start,
18329                                const unsigned char * const end)
18330 {
18331   printf (_("  Unknown GNU attribute: %s\n"), start);
18332
18333   start += strnlen ((char *) start, end - start);
18334   display_raw_attribute (start, end);
18335
18336   return (unsigned char *) end;
18337 }
18338
18339 static unsigned char *
18340 display_generic_attribute (unsigned char * start,
18341                            unsigned int tag,
18342                            const unsigned char * const end)
18343 {
18344   if (tag == 0)
18345     return (unsigned char *) end;
18346
18347   return display_tag_value (tag, start, end);
18348 }
18349
18350 static bfd_boolean
18351 process_arch_specific (Filedata * filedata)
18352 {
18353   if (! do_arch)
18354     return TRUE;
18355
18356   switch (filedata->file_header.e_machine)
18357     {
18358     case EM_ARC:
18359     case EM_ARC_COMPACT:
18360     case EM_ARC_COMPACT2:
18361       return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
18362                                  display_arc_attribute,
18363                                  display_generic_attribute);
18364     case EM_ARM:
18365       return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
18366                                  display_arm_attribute,
18367                                  display_generic_attribute);
18368
18369     case EM_MIPS:
18370     case EM_MIPS_RS3_LE:
18371       return process_mips_specific (filedata);
18372
18373     case EM_MSP430:
18374      return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
18375                                 display_msp430x_attribute,
18376                                 display_generic_attribute);
18377
18378     case EM_NDS32:
18379       return process_nds32_specific (filedata);
18380
18381     case EM_PPC:
18382     case EM_PPC64:
18383       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18384                                  display_power_gnu_attribute);
18385
18386     case EM_S390:
18387     case EM_S390_OLD:
18388       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18389                                  display_s390_gnu_attribute);
18390
18391     case EM_SPARC:
18392     case EM_SPARC32PLUS:
18393     case EM_SPARCV9:
18394       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18395                                  display_sparc_gnu_attribute);
18396
18397     case EM_TI_C6000:
18398       return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
18399                                  display_tic6x_attribute,
18400                                  display_generic_attribute);
18401
18402     default:
18403       return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
18404                                  display_public_gnu_attributes,
18405                                  display_generic_attribute);
18406     }
18407 }
18408
18409 static bfd_boolean
18410 get_file_header (Filedata * filedata)
18411 {
18412   /* Read in the identity array.  */
18413   if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
18414     return FALSE;
18415
18416   /* Determine how to read the rest of the header.  */
18417   switch (filedata->file_header.e_ident[EI_DATA])
18418     {
18419     default:
18420     case ELFDATANONE:
18421     case ELFDATA2LSB:
18422       byte_get = byte_get_little_endian;
18423       byte_put = byte_put_little_endian;
18424       break;
18425     case ELFDATA2MSB:
18426       byte_get = byte_get_big_endian;
18427       byte_put = byte_put_big_endian;
18428       break;
18429     }
18430
18431   /* For now we only support 32 bit and 64 bit ELF files.  */
18432   is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
18433
18434   /* Read in the rest of the header.  */
18435   if (is_32bit_elf)
18436     {
18437       Elf32_External_Ehdr ehdr32;
18438
18439       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
18440         return FALSE;
18441
18442       filedata->file_header.e_type      = BYTE_GET (ehdr32.e_type);
18443       filedata->file_header.e_machine   = BYTE_GET (ehdr32.e_machine);
18444       filedata->file_header.e_version   = BYTE_GET (ehdr32.e_version);
18445       filedata->file_header.e_entry     = BYTE_GET (ehdr32.e_entry);
18446       filedata->file_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
18447       filedata->file_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
18448       filedata->file_header.e_flags     = BYTE_GET (ehdr32.e_flags);
18449       filedata->file_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
18450       filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
18451       filedata->file_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
18452       filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
18453       filedata->file_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
18454       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
18455     }
18456   else
18457     {
18458       Elf64_External_Ehdr ehdr64;
18459
18460       /* If we have been compiled with sizeof (bfd_vma) == 4, then
18461          we will not be able to cope with the 64bit data found in
18462          64 ELF files.  Detect this now and abort before we start
18463          overwriting things.  */
18464       if (sizeof (bfd_vma) < 8)
18465         {
18466           error (_("This instance of readelf has been built without support for a\n\
18467 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18468           return FALSE;
18469         }
18470
18471       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
18472         return FALSE;
18473
18474       filedata->file_header.e_type      = BYTE_GET (ehdr64.e_type);
18475       filedata->file_header.e_machine   = BYTE_GET (ehdr64.e_machine);
18476       filedata->file_header.e_version   = BYTE_GET (ehdr64.e_version);
18477       filedata->file_header.e_entry     = BYTE_GET (ehdr64.e_entry);
18478       filedata->file_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
18479       filedata->file_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
18480       filedata->file_header.e_flags     = BYTE_GET (ehdr64.e_flags);
18481       filedata->file_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
18482       filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
18483       filedata->file_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
18484       filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
18485       filedata->file_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
18486       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
18487     }
18488
18489   if (filedata->file_header.e_shoff)
18490     {
18491       /* There may be some extensions in the first section header.  Don't
18492          bomb if we can't read it.  */
18493       if (is_32bit_elf)
18494         get_32bit_section_headers (filedata, TRUE);
18495       else
18496         get_64bit_section_headers (filedata, TRUE);
18497     }
18498
18499   return TRUE;
18500 }
18501
18502 static void
18503 close_file (Filedata * filedata)
18504 {
18505   if (filedata)
18506     {
18507       if (filedata->handle)
18508         fclose (filedata->handle);
18509       free (filedata);
18510     }
18511 }
18512
18513 void
18514 close_debug_file (void * data)
18515 {
18516   close_file ((Filedata *) data);
18517 }
18518
18519 static Filedata *
18520 open_file (const char * pathname)
18521 {
18522   struct stat  statbuf;
18523   Filedata *   filedata = NULL;
18524
18525   if (stat (pathname, & statbuf) < 0
18526       || ! S_ISREG (statbuf.st_mode))
18527     goto fail;
18528
18529   filedata = calloc (1, sizeof * filedata);
18530   if (filedata == NULL)
18531     goto fail;
18532
18533   filedata->handle = fopen (pathname, "rb");
18534   if (filedata->handle == NULL)
18535     goto fail;
18536
18537   filedata->file_size = (bfd_size_type) statbuf.st_size;
18538   filedata->file_name = pathname;
18539
18540   if (! get_file_header (filedata))
18541     goto fail;
18542
18543   if (filedata->file_header.e_shoff)
18544     {
18545       bfd_boolean res;
18546
18547       /* Read the section headers again, this time for real.  */
18548       if (is_32bit_elf)
18549         res = get_32bit_section_headers (filedata, FALSE);
18550       else
18551         res = get_64bit_section_headers (filedata, FALSE);
18552
18553       if (!res)
18554         goto fail;
18555     }
18556
18557   return filedata;
18558
18559  fail:
18560   if (filedata)
18561     {
18562       if (filedata->handle)
18563         fclose (filedata->handle);
18564       free (filedata);
18565     }
18566   return NULL;
18567 }
18568
18569 void *
18570 open_debug_file (const char * pathname)
18571 {
18572   return open_file (pathname);
18573 }
18574
18575 /* Process one ELF object file according to the command line options.
18576    This file may actually be stored in an archive.  The file is
18577    positioned at the start of the ELF object.  Returns TRUE if no
18578    problems were encountered, FALSE otherwise.  */
18579
18580 static bfd_boolean
18581 process_object (Filedata * filedata)
18582 {
18583   Filedata * separates;
18584   unsigned int i;
18585   bfd_boolean res = TRUE;
18586
18587   if (! get_file_header (filedata))
18588     {
18589       error (_("%s: Failed to read file header\n"), filedata->file_name);
18590       return FALSE;
18591     }
18592
18593   /* Initialise per file variables.  */
18594   for (i = ARRAY_SIZE (version_info); i--;)
18595     version_info[i] = 0;
18596
18597   for (i = ARRAY_SIZE (dynamic_info); i--;)
18598     dynamic_info[i] = 0;
18599   dynamic_info_DT_GNU_HASH = 0;
18600
18601   /* Process the file.  */
18602   if (show_name)
18603     printf (_("\nFile: %s\n"), filedata->file_name);
18604
18605   /* Initialise the dump_sects array from the cmdline_dump_sects array.
18606      Note we do this even if cmdline_dump_sects is empty because we
18607      must make sure that the dump_sets array is zeroed out before each
18608      object file is processed.  */
18609   if (filedata->num_dump_sects > cmdline.num_dump_sects)
18610     memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
18611
18612   if (cmdline.num_dump_sects > 0)
18613     {
18614       if (filedata->num_dump_sects == 0)
18615         /* A sneaky way of allocating the dump_sects array.  */
18616         request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
18617
18618       assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
18619       memcpy (filedata->dump_sects, cmdline.dump_sects,
18620               cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
18621     }
18622
18623   if (! process_file_header (filedata))
18624     return FALSE;
18625
18626   if (! process_section_headers (filedata))
18627     {
18628       /* Without loaded section headers we cannot process lots of things.  */
18629       do_unwind = do_version = do_dump = do_arch = FALSE;
18630
18631       if (! do_using_dynamic)
18632         do_syms = do_dyn_syms = do_reloc = FALSE;
18633     }
18634
18635   if (! process_section_groups (filedata))
18636     /* Without loaded section groups we cannot process unwind.  */
18637     do_unwind = FALSE;
18638
18639   if (process_program_headers (filedata))
18640     process_dynamic_section (filedata);
18641   else
18642     res = FALSE;
18643
18644   if (! process_relocs (filedata))
18645     res = FALSE;
18646
18647   if (! process_unwind (filedata))
18648     res = FALSE;
18649
18650   if (! process_symbol_table (filedata))
18651     res = FALSE;
18652
18653   if (! process_syminfo (filedata))
18654     res = FALSE;
18655
18656   if (! process_version_sections (filedata))
18657     res = FALSE;
18658
18659   if (filedata->file_header.e_shstrndx != SHN_UNDEF)
18660     separates = load_separate_debug_file (filedata, filedata->file_name);
18661   else
18662     separates = NULL;
18663
18664   if (! process_section_contents (filedata))
18665     res = FALSE;
18666
18667   if (separates)
18668     {
18669       if (! process_section_headers (separates))
18670         res = FALSE;
18671       else if (! process_section_contents (separates))
18672         res = FALSE;
18673     }
18674
18675   if (! process_notes (filedata))
18676     res = FALSE;
18677
18678   if (! process_gnu_liblist (filedata))
18679     res = FALSE;
18680
18681   if (! process_arch_specific (filedata))
18682     res = FALSE;
18683
18684   free (filedata->program_headers);
18685   filedata->program_headers = NULL;
18686
18687   free (filedata->section_headers);
18688   filedata->section_headers = NULL;
18689
18690   free (filedata->string_table);
18691   filedata->string_table = NULL;
18692   filedata->string_table_length = 0;
18693
18694   if (dynamic_strings)
18695     {
18696       free (dynamic_strings);
18697       dynamic_strings = NULL;
18698       dynamic_strings_length = 0;
18699     }
18700
18701   if (dynamic_symbols)
18702     {
18703       free (dynamic_symbols);
18704       dynamic_symbols = NULL;
18705       num_dynamic_syms = 0;
18706     }
18707
18708   if (dynamic_syminfo)
18709     {
18710       free (dynamic_syminfo);
18711       dynamic_syminfo = NULL;
18712     }
18713
18714   if (dynamic_section)
18715     {
18716       free (dynamic_section);
18717       dynamic_section = NULL;
18718     }
18719
18720   if (section_headers_groups)
18721     {
18722       free (section_headers_groups);
18723       section_headers_groups = NULL;
18724     }
18725
18726   if (section_groups)
18727     {
18728       struct group_list * g;
18729       struct group_list * next;
18730
18731       for (i = 0; i < group_count; i++)
18732         {
18733           for (g = section_groups [i].root; g != NULL; g = next)
18734             {
18735               next = g->next;
18736               free (g);
18737             }
18738         }
18739
18740       free (section_groups);
18741       section_groups = NULL;
18742     }
18743
18744   free_debug_memory ();
18745
18746   return res;
18747 }
18748
18749 /* Process an ELF archive.
18750    On entry the file is positioned just after the ARMAG string.
18751    Returns TRUE upon success, FALSE otherwise.  */
18752
18753 static bfd_boolean
18754 process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
18755 {
18756   struct archive_info arch;
18757   struct archive_info nested_arch;
18758   size_t got;
18759   bfd_boolean ret = TRUE;
18760
18761   show_name = TRUE;
18762
18763   /* The ARCH structure is used to hold information about this archive.  */
18764   arch.file_name = NULL;
18765   arch.file = NULL;
18766   arch.index_array = NULL;
18767   arch.sym_table = NULL;
18768   arch.longnames = NULL;
18769
18770   /* The NESTED_ARCH structure is used as a single-item cache of information
18771      about a nested archive (when members of a thin archive reside within
18772      another regular archive file).  */
18773   nested_arch.file_name = NULL;
18774   nested_arch.file = NULL;
18775   nested_arch.index_array = NULL;
18776   nested_arch.sym_table = NULL;
18777   nested_arch.longnames = NULL;
18778
18779   if (setup_archive (&arch, filedata->file_name, filedata->handle,
18780                      is_thin_archive, do_archive_index) != 0)
18781     {
18782       ret = FALSE;
18783       goto out;
18784     }
18785
18786   if (do_archive_index)
18787     {
18788       if (arch.sym_table == NULL)
18789         error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
18790       else
18791         {
18792           unsigned long i, l;
18793           unsigned long current_pos;
18794
18795           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18796                   filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
18797
18798           current_pos = ftell (filedata->handle);
18799
18800           for (i = l = 0; i < arch.index_num; i++)
18801             {
18802               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
18803                 {
18804                   char * member_name;
18805
18806                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
18807
18808                   if (member_name != NULL)
18809                     {
18810                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
18811
18812                       if (qualified_name != NULL)
18813                         {
18814                           printf (_("Contents of binary %s at offset "), qualified_name);
18815                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
18816                           putchar ('\n');
18817                           free (qualified_name);
18818                         }
18819                     }
18820                 }
18821
18822               if (l >= arch.sym_size)
18823                 {
18824                   error (_("%s: end of the symbol table reached before the end of the index\n"),
18825                          filedata->file_name);
18826                   ret = FALSE;
18827                   break;
18828                 }
18829               /* PR 17531: file: 0b6630b2.  */
18830               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
18831               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
18832             }
18833
18834           if (arch.uses_64bit_indicies)
18835             l = (l + 7) & ~ 7;
18836           else
18837             l += l & 1;
18838
18839           if (l < arch.sym_size)
18840             {
18841               error (ngettext ("%s: %ld byte remains in the symbol table, "
18842                                "but without corresponding entries in "
18843                                "the index table\n",
18844                                "%s: %ld bytes remain in the symbol table, "
18845                                "but without corresponding entries in "
18846                                "the index table\n",
18847                                arch.sym_size - l),
18848                      filedata->file_name, arch.sym_size - l);
18849               ret = FALSE;
18850             }
18851
18852           if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
18853             {
18854               error (_("%s: failed to seek back to start of object files in the archive\n"),
18855                      filedata->file_name);
18856               ret = FALSE;
18857               goto out;
18858             }
18859         }
18860
18861       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
18862           && !do_segments && !do_header && !do_dump && !do_version
18863           && !do_histogram && !do_debugging && !do_arch && !do_notes
18864           && !do_section_groups && !do_dyn_syms)
18865         {
18866           ret = TRUE; /* Archive index only.  */
18867           goto out;
18868         }
18869     }
18870
18871   while (1)
18872     {
18873       char * name;
18874       size_t namelen;
18875       char * qualified_name;
18876
18877       /* Read the next archive header.  */
18878       if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
18879         {
18880           error (_("%s: failed to seek to next archive header\n"), filedata->file_name);
18881           return FALSE;
18882         }
18883       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
18884       if (got != sizeof arch.arhdr)
18885         {
18886           if (got == 0)
18887             break;
18888           error (_("%s: failed to read archive header\n"), filedata->file_name);
18889           ret = FALSE;
18890           break;
18891         }
18892       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
18893         {
18894           error (_("%s: did not find a valid archive header\n"), arch.file_name);
18895           ret = FALSE;
18896           break;
18897         }
18898
18899       arch.next_arhdr_offset += sizeof arch.arhdr;
18900
18901       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
18902       if (archive_file_size & 01)
18903         ++archive_file_size;
18904
18905       name = get_archive_member_name (&arch, &nested_arch);
18906       if (name == NULL)
18907         {
18908           error (_("%s: bad archive file name\n"), filedata->file_name);
18909           ret = FALSE;
18910           break;
18911         }
18912       namelen = strlen (name);
18913
18914       qualified_name = make_qualified_name (&arch, &nested_arch, name);
18915       if (qualified_name == NULL)
18916         {
18917           error (_("%s: bad archive file name\n"), filedata->file_name);
18918           ret = FALSE;
18919           break;
18920         }
18921
18922       if (is_thin_archive && arch.nested_member_origin == 0)
18923         {
18924           /* This is a proxy for an external member of a thin archive.  */
18925           Filedata * member_filedata;
18926           char * member_file_name = adjust_relative_path
18927             (filedata->file_name, name, namelen);
18928
18929           if (member_file_name == NULL)
18930             {
18931               ret = FALSE;
18932               break;
18933             }
18934
18935           member_filedata = open_file (member_file_name);
18936           if (member_filedata == NULL)
18937             {
18938               error (_("Input file '%s' is not readable.\n"), member_file_name);
18939               free (member_file_name);
18940               ret = FALSE;
18941               break;
18942             }
18943
18944           archive_file_offset = arch.nested_member_origin;
18945           member_filedata->file_name = qualified_name;
18946
18947           if (! process_object (member_filedata))
18948             ret = FALSE;
18949
18950           close_file (member_filedata);
18951           free (member_file_name);
18952         }
18953       else if (is_thin_archive)
18954         {
18955           Filedata thin_filedata;
18956
18957           memset (&thin_filedata, 0, sizeof (thin_filedata));
18958
18959           /* PR 15140: Allow for corrupt thin archives.  */
18960           if (nested_arch.file == NULL)
18961             {
18962               error (_("%s: contains corrupt thin archive: %s\n"),
18963                      filedata->file_name, name);
18964               ret = FALSE;
18965               break;
18966             }
18967
18968           /* This is a proxy for a member of a nested archive.  */
18969           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
18970
18971           /* The nested archive file will have been opened and setup by
18972              get_archive_member_name.  */
18973           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
18974             {
18975               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
18976               ret = FALSE;
18977               break;
18978             }
18979
18980           thin_filedata.handle = nested_arch.file;
18981           thin_filedata.file_name = qualified_name;
18982
18983           if (! process_object (& thin_filedata))
18984             ret = FALSE;
18985         }
18986       else
18987         {
18988           archive_file_offset = arch.next_arhdr_offset;
18989           arch.next_arhdr_offset += archive_file_size;
18990
18991           filedata->file_name = qualified_name;
18992           if (! process_object (filedata))
18993             ret = FALSE;
18994         }
18995
18996       if (filedata->dump_sects != NULL)
18997         {
18998           free (filedata->dump_sects);
18999           filedata->dump_sects = NULL;
19000           filedata->num_dump_sects = 0;
19001         }
19002
19003       free (qualified_name);
19004     }
19005
19006  out:
19007   if (nested_arch.file != NULL)
19008     fclose (nested_arch.file);
19009   release_archive (&nested_arch);
19010   release_archive (&arch);
19011
19012   return ret;
19013 }
19014
19015 static bfd_boolean
19016 process_file (char * file_name)
19017 {
19018   Filedata * filedata = NULL;
19019   struct stat statbuf;
19020   char armag[SARMAG];
19021   bfd_boolean ret = TRUE;
19022
19023   if (stat (file_name, &statbuf) < 0)
19024     {
19025       if (errno == ENOENT)
19026         error (_("'%s': No such file\n"), file_name);
19027       else
19028         error (_("Could not locate '%s'.  System error message: %s\n"),
19029                file_name, strerror (errno));
19030       return FALSE;
19031     }
19032
19033   if (! S_ISREG (statbuf.st_mode))
19034     {
19035       error (_("'%s' is not an ordinary file\n"), file_name);
19036       return FALSE;
19037     }
19038
19039   filedata = calloc (1, sizeof * filedata);
19040   if (filedata == NULL)
19041     {
19042       error (_("Out of memory allocating file data structure\n"));
19043       return FALSE;
19044     }
19045
19046   filedata->file_name = file_name;
19047   filedata->handle = fopen (file_name, "rb");
19048   if (filedata->handle == NULL)
19049     {
19050       error (_("Input file '%s' is not readable.\n"), file_name);
19051       free (filedata);
19052       return FALSE;
19053     }
19054
19055   if (fread (armag, SARMAG, 1, filedata->handle) != 1)
19056     {
19057       error (_("%s: Failed to read file's magic number\n"), file_name);
19058       fclose (filedata->handle);
19059       free (filedata);
19060       return FALSE;
19061     }
19062
19063   filedata->file_size = (bfd_size_type) statbuf.st_size;
19064
19065   if (memcmp (armag, ARMAG, SARMAG) == 0)
19066     {
19067       if (! process_archive (filedata, FALSE))
19068         ret = FALSE;
19069     }
19070   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
19071     {
19072       if ( ! process_archive (filedata, TRUE))
19073         ret = FALSE;
19074     }
19075   else
19076     {
19077       if (do_archive_index)
19078         error (_("File %s is not an archive so its index cannot be displayed.\n"),
19079                file_name);
19080
19081       rewind (filedata->handle);
19082       archive_file_size = archive_file_offset = 0;
19083
19084       if (! process_object (filedata))
19085         ret = FALSE;
19086     }
19087
19088   fclose (filedata->handle);
19089   free (filedata);
19090
19091   return ret;
19092 }
19093
19094 #ifdef SUPPORT_DISASSEMBLY
19095 /* Needed by the i386 disassembler.  For extra credit, someone could
19096    fix this so that we insert symbolic addresses here, esp for GOT/PLT
19097    symbols.  */
19098
19099 void
19100 print_address (unsigned int addr, FILE * outfile)
19101 {
19102   fprintf (outfile,"0x%8.8x", addr);
19103 }
19104
19105 /* Needed by the i386 disassembler.  */
19106
19107 void
19108 db_task_printsym (unsigned int addr)
19109 {
19110   print_address (addr, stderr);
19111 }
19112 #endif
19113
19114 int
19115 main (int argc, char ** argv)
19116 {
19117   int err;
19118
19119 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19120   setlocale (LC_MESSAGES, "");
19121 #endif
19122 #if defined (HAVE_SETLOCALE)
19123   setlocale (LC_CTYPE, "");
19124 #endif
19125   bindtextdomain (PACKAGE, LOCALEDIR);
19126   textdomain (PACKAGE);
19127
19128   expandargv (&argc, &argv);
19129
19130   cmdline.file_name = "<cmdline>";
19131   parse_args (& cmdline, argc, argv);
19132
19133   if (optind < (argc - 1))
19134     show_name = TRUE;
19135   else if (optind >= argc)
19136     {
19137       warn (_("Nothing to do.\n"));
19138       usage (stderr);
19139     }
19140
19141   err = FALSE;
19142   while (optind < argc)
19143     if (! process_file (argv[optind++]))
19144       err = TRUE;
19145
19146   if (cmdline.dump_sects != NULL)
19147     free (cmdline.dump_sects);
19148
19149   return err ? EXIT_FAILURE : EXIT_SUCCESS;
19150 }