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/csky.h"
 102 #include "elf/d10v.h"
 103 #include "elf/d30v.h"
 104 #include "elf/dlx.h"
 105 #include "elf/epiphany.h"
 106 #include "elf/fr30.h"
 107 #include "elf/frv.h"
 108 #include "elf/ft32.h"
 109 #include "elf/h8.h"
 110 #include "elf/hppa.h"
 111 #include "elf/i386.h"
 112 #include "elf/i370.h"
 113 #include "elf/i860.h"
 114 #include "elf/i960.h"
 115 #include "elf/ia64.h"
 116 #include "elf/ip2k.h"
 117 #include "elf/lm32.h"
 118 #include "elf/iq2000.h"
 119 #include "elf/m32c.h"
 120 #include "elf/m32r.h"
 121 #include "elf/m68k.h"
 122 #include "elf/m68hc11.h"
 123 #include "elf/s12z.h"
 124 #include "elf/mcore.h"
 125 #include "elf/mep.h"
 126 #include "elf/metag.h"
 127 #include "elf/microblaze.h"
 128 #include "elf/mips.h"
 129 #include "elf/mmix.h"
 130 #include "elf/mn10200.h"
 131 #include "elf/mn10300.h"
 132 #include "elf/moxie.h"
 133 #include "elf/mt.h"
 134 #include "elf/msp430.h"
 135 #include "elf/nds32.h"
 136 #include "elf/nfp.h"
 137 #include "elf/nios2.h"
 138 #include "elf/or1k.h"
 139 #include "elf/pj.h"
 140 #include "elf/ppc.h"
 141 #include "elf/ppc64.h"
 142 #include "elf/pru.h"
 143 #include "elf/riscv.h"
 144 #include "elf/rl78.h"
 145 #include "elf/rx.h"
 146 #include "elf/s390.h"
 147 #include "elf/score.h"
 148 #include "elf/sh.h"
 149 #include "elf/sparc.h"
 150 #include "elf/spu.h"
 151 #include "elf/tic6x.h"
 152 #include "elf/tilegx.h"
 153 #include "elf/tilepro.h"
 154 #include "elf/v850.h"
 155 #include "elf/vax.h"
 156 #include "elf/visium.h"
 157 #include "elf/wasm32.h"
 158 #include "elf/x86-64.h"
 159 #include "elf/xc16x.h"
 160 #include "elf/xgate.h"
 161 #include "elf/xstormy16.h"
 162 #include "elf/xtensa.h"
 163
 164 #include "getopt.h"
 165 #include "libiberty.h"
 166 #include "safe-ctype.h"
 167 #include "filenames.h"
 168
 169 #ifndef offsetof
 170 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
 171 #endif
 172
 173 typedef struct elf_section_list
 174 {
 175   Elf_Internal_Shdr *        hdr;
 176   struct elf_section_list *  next;
 177 } elf_section_list;
 178
 179 /* Flag bits indicating particular types of dump.  */
 180 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
 181 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
 182 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
 183 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
 184 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
 185
 186 typedef unsigned char dump_type;
 187
 188 /* A linked list of the section names for which dumps were requested.  */
 189 struct dump_list_entry
 190 {
 191   char *                    name;
 192   dump_type                 type;
 193   struct dump_list_entry *  next;
 194 };
 195
 196 typedef struct filedata
 197 {
 198   const char *         file_name;
 199   FILE *               handle;
 200   bfd_size_type        file_size;
 201   Elf_Internal_Ehdr    file_header;
 202   Elf_Internal_Shdr *  section_headers;
 203   Elf_Internal_Phdr *  program_headers;
 204   char *               string_table;
 205   unsigned long        string_table_length;
 206   /* A dynamic array of flags indicating for which sections a dump of
 207      some kind has been requested.  It is reset on a per-object file
 208      basis and then initialised from the cmdline_dump_sects array,
 209      the results of interpreting the -w switch, and the
 210      dump_sects_byname list.  */
 211   dump_type *          dump_sects;
 212   unsigned int         num_dump_sects;
 213 } Filedata;
 214
 215 char * program_name = "readelf";
 216
 217 static unsigned long archive_file_offset;
 218 static unsigned long archive_file_size;
 219 static unsigned long dynamic_addr;
 220 static bfd_size_type dynamic_size;
 221 static size_t dynamic_nent;
 222 static char * dynamic_strings;
 223 static unsigned long dynamic_strings_length;
 224 static unsigned long num_dynamic_syms;
 225 static Elf_Internal_Sym * dynamic_symbols;
 226 static Elf_Internal_Syminfo * dynamic_syminfo;
 227 static unsigned long dynamic_syminfo_offset;
 228 static unsigned int dynamic_syminfo_nent;
 229 static char program_interpreter[PATH_MAX];
 230 static bfd_vma dynamic_info[DT_ENCODING];
 231 static bfd_vma dynamic_info_DT_GNU_HASH;
 232 static bfd_vma version_info[16];
 233 static Elf_Internal_Dyn *  dynamic_section;
 234 static elf_section_list * symtab_shndx_list;
 235 static bfd_boolean show_name = FALSE;
 236 static bfd_boolean do_dynamic = FALSE;
 237 static bfd_boolean do_syms = FALSE;
 238 static bfd_boolean do_dyn_syms = FALSE;
 239 static bfd_boolean do_reloc = FALSE;
 240 static bfd_boolean do_sections = FALSE;
 241 static bfd_boolean do_section_groups = FALSE;
 242 static bfd_boolean do_section_details = FALSE;
 243 static bfd_boolean do_segments = FALSE;
 244 static bfd_boolean do_unwind = FALSE;
 245 static bfd_boolean do_using_dynamic = FALSE;
 246 static bfd_boolean do_header = FALSE;
 247 static bfd_boolean do_dump = FALSE;
 248 static bfd_boolean do_version = FALSE;
 249 static bfd_boolean do_histogram = FALSE;
 250 static bfd_boolean do_debugging = FALSE;
 251 static bfd_boolean do_arch = FALSE;
 252 static bfd_boolean do_notes = FALSE;
 253 static bfd_boolean do_archive_index = FALSE;
 254 static bfd_boolean is_32bit_elf = FALSE;
 255 static bfd_boolean decompress_dumps = FALSE;
 256
 257 struct group_list
 258 {
 259   struct group_list *  next;
 260   unsigned int         section_index;
 261 };
 262
 263 struct group
 264 {
 265   struct group_list *  root;
 266   unsigned int         group_index;
 267 };
 268
 269 static size_t           group_count;
 270 static struct group *   section_groups;
 271 static struct group **  section_headers_groups;
 272
 273 /* A dynamic array of flags indicating for which sections a dump
 274    has been requested via command line switches.  */
 275 static Filedata         cmdline;
 276
 277 static struct dump_list_entry * dump_sects_byname;
 278
 279 /* How to print a vma value.  */
 280 typedef enum print_mode
 281 {
 282   HEX,
 283   DEC,
 284   DEC_5,
 285   UNSIGNED,
 286   PREFIX_HEX,
 287   FULL_HEX,
 288   LONG_HEX
 289 }
 290 print_mode;
 291
 292 /* Versioned symbol info.  */
 293 enum versioned_symbol_info
 294 {
 295   symbol_undefined,
 296   symbol_hidden,
 297   symbol_public
 298 };
 299
 300 static const char * get_symbol_version_string
 301   (Filedata *, bfd_boolean, const char *, unsigned long, unsigned,
 302    Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
 303
 304 #define UNKNOWN -1
 305
 306 #define SECTION_NAME(X)                                         \
 307   ((X) == NULL ? _("<none>")                                    \
 308    : filedata->string_table == NULL ? _("<no-strings>")         \
 309    : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>")    \
 310   : filedata->string_table + (X)->sh_name))
 311
 312 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 313
 314 #define GET_ELF_SYMBOLS(file, section, sym_count)                       \
 315   (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count)      \
 316    : get_64bit_elf_symbols (file, section, sym_count))
 317
 318 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
 319 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 320    already been called and verified that the string exists.  */
 321 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
 322
 323 #define REMOVE_ARCH_BITS(ADDR)                  \
 324   do                                            \
 325     {                                           \
 326       if (filedata->file_header.e_machine == EM_ARM)    \
 327         (ADDR) &= ~1;                           \
 328     }                                           \
 329   while (0)
 330 \f
 331 /* Print a BFD_VMA to an internal buffer, for use in error messages.
 332    BFD_FMA_FMT can't be used in translated strings.  */
 333
 334 static const char *
 335 bfd_vmatoa (char *fmtch, bfd_vma value)
 336 {
 337   /* bfd_vmatoa is used more then once in a printf call for output.
 338      Cycle through an array of buffers.  */
 339   static int buf_pos = 0;
 340   static struct bfd_vmatoa_buf
 341   {
 342     char place[64];
 343   } buf[4];
 344   char *ret;
 345   char fmt[32];
 346
 347   ret = buf[buf_pos++].place;
 348   buf_pos %= ARRAY_SIZE (buf);
 349
 350   sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch);
 351   snprintf (ret, sizeof (buf[0].place), fmt, value);
 352   return ret;
 353 }
 354
 355 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
 356    OFFSET + the offset of the current archive member, if we are examining an
 357    archive.  Put the retrieved data into VAR, if it is not NULL.  Otherwise
 358    allocate a buffer using malloc and fill that.  In either case return the
 359    pointer to the start of the retrieved data or NULL if something went wrong.
 360    If something does go wrong and REASON is not NULL then emit an error
 361    message using REASON as part of the context.  */
 362
 363 static void *
 364 get_data (void *         var,
 365           Filedata *     filedata,
 366           unsigned long  offset,
 367           bfd_size_type  size,
 368           bfd_size_type  nmemb,
 369           const char *   reason)
 370 {
 371   void * mvar;
 372   bfd_size_type amt = size * nmemb;
 373
 374   if (size == 0 || nmemb == 0)
 375     return NULL;
 376
 377   /* If the size_t type is smaller than the bfd_size_type, eg because
 378      you are building a 32-bit tool on a 64-bit host, then make sure
 379      that when the sizes are cast to (size_t) no information is lost.  */
 380   if (sizeof (size_t) < sizeof (bfd_size_type)
 381       && (   (bfd_size_type) ((size_t) size) != size
 382           || (bfd_size_type) ((size_t) nmemb) != nmemb))
 383     {
 384       if (reason)
 385         error (_("Size truncation prevents reading %s"
 386                  " elements of size %s for %s\n"),
 387                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 388       return NULL;
 389     }
 390
 391   /* Check for size overflow.  */
 392   if (amt < nmemb)
 393     {
 394       if (reason)
 395         error (_("Size overflow prevents reading %s"
 396                  " elements of size %s for %s\n"),
 397                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 398       return NULL;
 399     }
 400
 401   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
 402      attempting to allocate memory when the read is bound to fail.  */
 403   if (amt > filedata->file_size
 404       || offset + archive_file_offset + amt > filedata->file_size)
 405     {
 406       if (reason)
 407         error (_("Reading %s bytes extends past end of file for %s\n"),
 408                bfd_vmatoa ("u", amt), reason);
 409       return NULL;
 410     }
 411
 412   if (fseek (filedata->handle, archive_file_offset + offset, SEEK_SET))
 413     {
 414       if (reason)
 415         error (_("Unable to seek to 0x%lx for %s\n"),
 416                archive_file_offset + offset, reason);
 417       return NULL;
 418     }
 419
 420   mvar = var;
 421   if (mvar == NULL)
 422     {
 423       /* Check for overflow.  */
 424       if (nmemb < (~(bfd_size_type) 0 - 1) / size)
 425         /* + 1 so that we can '\0' terminate invalid string table sections.  */
 426         mvar = malloc ((size_t) amt + 1);
 427
 428       if (mvar == NULL)
 429         {
 430           if (reason)
 431             error (_("Out of memory allocating %s bytes for %s\n"),
 432                    bfd_vmatoa ("u", amt), reason);
 433           return NULL;
 434         }
 435
 436       ((char *) mvar)[amt] = '\0';
 437     }
 438
 439   if (fread (mvar, (size_t) size, (size_t) nmemb, filedata->handle) != nmemb)
 440     {
 441       if (reason)
 442         error (_("Unable to read in %s bytes of %s\n"),
 443                bfd_vmatoa ("u", amt), reason);
 444       if (mvar != var)
 445         free (mvar);
 446       return NULL;
 447     }
 448
 449   return mvar;
 450 }
 451
 452 /* Print a VMA value in the MODE specified.
 453    Returns the number of characters displayed.  */
 454
 455 static unsigned int
 456 print_vma (bfd_vma vma, print_mode mode)
 457 {
 458   unsigned int nc = 0;
 459
 460   switch (mode)
 461     {
 462     case FULL_HEX:
 463       nc = printf ("0x");
 464       /* Fall through.  */
 465     case LONG_HEX:
 466 #ifdef BFD64
 467       if (is_32bit_elf)
 468         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
 469 #endif
 470       printf_vma (vma);
 471       return nc + 16;
 472
 473     case DEC_5:
 474       if (vma <= 99999)
 475         return printf ("%5" BFD_VMA_FMT "d", vma);
 476       /* Fall through.  */
 477     case PREFIX_HEX:
 478       nc = printf ("0x");
 479       /* Fall through.  */
 480     case HEX:
 481       return nc + printf ("%" BFD_VMA_FMT "x", vma);
 482
 483     case DEC:
 484       return printf ("%" BFD_VMA_FMT "d", vma);
 485
 486     case UNSIGNED:
 487       return printf ("%" BFD_VMA_FMT "u", vma);
 488
 489     default:
 490       /* FIXME: Report unrecognised mode ?  */
 491       return 0;
 492     }
 493 }
 494
 495 /* Display a symbol on stdout.  Handles the display of control characters and
 496    multibye characters (assuming the host environment supports them).
 497
 498    Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
 499
 500    If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
 501    padding as necessary.
 502
 503    Returns the number of emitted characters.  */
 504
 505 static unsigned int
 506 print_symbol (signed int width, const char *symbol)
 507 {
 508   bfd_boolean extra_padding = FALSE;
 509   signed int num_printed = 0;
 510 #ifdef HAVE_MBSTATE_T
 511   mbstate_t state;
 512 #endif
 513   unsigned int width_remaining;
 514
 515   if (width < 0)
 516     {
 517       /* Keep the width positive.  This helps the code below.  */
 518       width = - width;
 519       extra_padding = TRUE;
 520     }
 521   else if (width == 0)
 522     return 0;
 523
 524   if (do_wide)
 525     /* Set the remaining width to a very large value.
 526        This simplifies the code below.  */
 527     width_remaining = INT_MAX;
 528   else
 529     width_remaining = width;
 530
 531 #ifdef HAVE_MBSTATE_T
 532   /* Initialise the multibyte conversion state.  */
 533   memset (& state, 0, sizeof (state));
 534 #endif
 535
 536   while (width_remaining)
 537     {
 538       size_t  n;
 539       const char c = *symbol++;
 540
 541       if (c == 0)
 542         break;
 543
 544       /* Do not print control characters directly as they can affect terminal
 545          settings.  Such characters usually appear in the names generated
 546          by the assembler for local labels.  */
 547       if (ISCNTRL (c))
 548         {
 549           if (width_remaining < 2)
 550             break;
 551
 552           printf ("^%c", c + 0x40);
 553           width_remaining -= 2;
 554           num_printed += 2;
 555         }
 556       else if (ISPRINT (c))
 557         {
 558           putchar (c);
 559           width_remaining --;
 560           num_printed ++;
 561         }
 562       else
 563         {
 564 #ifdef HAVE_MBSTATE_T
 565           wchar_t w;
 566 #endif
 567           /* Let printf do the hard work of displaying multibyte characters.  */
 568           printf ("%.1s", symbol - 1);
 569           width_remaining --;
 570           num_printed ++;
 571
 572 #ifdef HAVE_MBSTATE_T
 573           /* Try to find out how many bytes made up the character that was
 574              just printed.  Advance the symbol pointer past the bytes that
 575              were displayed.  */
 576           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 577 #else
 578           n = 1;
 579 #endif
 580           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 581             symbol += (n - 1);
 582         }
 583     }
 584
 585   if (extra_padding && num_printed < width)
 586     {
 587       /* Fill in the remaining spaces.  */
 588       printf ("%-*s", width - num_printed, " ");
 589       num_printed = width;
 590     }
 591
 592   return num_printed;
 593 }
 594
 595 /* Returns a pointer to a static buffer containing a printable version of
 596    the given section's name.  Like print_symbol, except that it does not try
 597    to print multibyte characters, it just interprets them as hex values.  */
 598
 599 static const char *
 600 printable_section_name (Filedata * filedata, const Elf_Internal_Shdr * sec)
 601 {
 602 #define MAX_PRINT_SEC_NAME_LEN 128
 603   static char  sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
 604   const char * name = SECTION_NAME (sec);
 605   char *       buf = sec_name_buf;
 606   char         c;
 607   unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
 608
 609   while ((c = * name ++) != 0)
 610     {
 611       if (ISCNTRL (c))
 612         {
 613           if (remaining < 2)
 614             break;
 615
 616           * buf ++ = '^';
 617           * buf ++ = c + 0x40;
 618           remaining -= 2;
 619         }
 620       else if (ISPRINT (c))
 621         {
 622           * buf ++ = c;
 623           remaining -= 1;
 624         }
 625       else
 626         {
 627           static char hex[17] = "0123456789ABCDEF";
 628
 629           if (remaining < 4)
 630             break;
 631           * buf ++ = '<';
 632           * buf ++ = hex[(c & 0xf0) >> 4];
 633           * buf ++ = hex[c & 0x0f];
 634           * buf ++ = '>';
 635           remaining -= 4;
 636         }
 637
 638       if (remaining == 0)
 639         break;
 640     }
 641
 642   * buf = 0;
 643   return sec_name_buf;
 644 }
 645
 646 static const char *
 647 printable_section_name_from_index (Filedata * filedata, unsigned long ndx)
 648 {
 649   if (ndx >= filedata->file_header.e_shnum)
 650     return _("<corrupt>");
 651
 652   return printable_section_name (filedata, filedata->section_headers + ndx);
 653 }
 654
 655 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 656
 657 static Elf_Internal_Shdr *
 658 find_section (Filedata * filedata, const char * name)
 659 {
 660   unsigned int i;
 661
 662   if (filedata->section_headers == NULL)
 663     return NULL;
 664
 665   for (i = 0; i < filedata->file_header.e_shnum; i++)
 666     if (streq (SECTION_NAME (filedata->section_headers + i), name))
 667       return filedata->section_headers + i;
 668
 669   return NULL;
 670 }
 671
 672 /* Return a pointer to a section containing ADDR, or NULL if no such
 673    section exists.  */
 674
 675 static Elf_Internal_Shdr *
 676 find_section_by_address (Filedata * filedata, bfd_vma addr)
 677 {
 678   unsigned int i;
 679
 680   if (filedata->section_headers == NULL)
 681     return NULL;
 682
 683   for (i = 0; i < filedata->file_header.e_shnum; i++)
 684     {
 685       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 686
 687       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 688         return sec;
 689     }
 690
 691   return NULL;
 692 }
 693
 694 static Elf_Internal_Shdr *
 695 find_section_by_type (Filedata * filedata, unsigned int type)
 696 {
 697   unsigned int i;
 698
 699   if (filedata->section_headers == NULL)
 700     return NULL;
 701
 702   for (i = 0; i < filedata->file_header.e_shnum; i++)
 703     {
 704       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 705
 706       if (sec->sh_type == type)
 707         return sec;
 708     }
 709
 710   return NULL;
 711 }
 712
 713 /* Return a pointer to section NAME, or NULL if no such section exists,
 714    restricted to the list of sections given in SET.  */
 715
 716 static Elf_Internal_Shdr *
 717 find_section_in_set (Filedata * filedata, const char * name, unsigned int * set)
 718 {
 719   unsigned int i;
 720
 721   if (filedata->section_headers == NULL)
 722     return NULL;
 723
 724   if (set != NULL)
 725     {
 726       while ((i = *set++) > 0)
 727         {
 728           /* See PR 21156 for a reproducer.  */
 729           if (i >= filedata->file_header.e_shnum)
 730             continue; /* FIXME: Should we issue an error message ?  */
 731
 732           if (streq (SECTION_NAME (filedata->section_headers + i), name))
 733             return filedata->section_headers + i;
 734         }
 735     }
 736
 737   return find_section (filedata, name);
 738 }
 739
 740 /* Read an unsigned LEB128 encoded value from DATA.
 741    Set *LENGTH_RETURN to the number of bytes read.  */
 742
 743 static inline unsigned long
 744 read_uleb128 (unsigned char * data,
 745               unsigned int * length_return,
 746               const unsigned char * const end)
 747 {
 748   return read_leb128 (data, length_return, FALSE, end);
 749 }
 750
 751 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
 752    This OS has so many departures from the ELF standard that we test it at
 753    many places.  */
 754
 755 static inline bfd_boolean
 756 is_ia64_vms (Filedata * filedata)
 757 {
 758   return filedata->file_header.e_machine == EM_IA_64
 759     && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 760 }
 761
 762 /* Guess the relocation size commonly used by the specific machines.  */
 763
 764 static bfd_boolean
 765 guess_is_rela (unsigned int e_machine)
 766 {
 767   switch (e_machine)
 768     {
 769       /* Targets that use REL relocations.  */
 770     case EM_386:
 771     case EM_IAMCU:
 772     case EM_960:
 773     case EM_ARM:
 774     case EM_D10V:
 775     case EM_CYGNUS_D10V:
 776     case EM_DLX:
 777     case EM_MIPS:
 778     case EM_MIPS_RS3_LE:
 779     case EM_CYGNUS_M32R:
 780     case EM_SCORE:
 781     case EM_XGATE:
 782     case EM_NFP:
 783       return FALSE;
 784
 785       /* Targets that use RELA relocations.  */
 786     case EM_68K:
 787     case EM_860:
 788     case EM_AARCH64:
 789     case EM_ADAPTEVA_EPIPHANY:
 790     case EM_ALPHA:
 791     case EM_ALTERA_NIOS2:
 792     case EM_ARC:
 793     case EM_ARC_COMPACT:
 794     case EM_ARC_COMPACT2:
 795     case EM_AVR:
 796     case EM_AVR_OLD:
 797     case EM_BLACKFIN:
 798     case EM_CR16:
 799     case EM_CRIS:
 800     case EM_CRX:
 801     case EM_CSKY:
 802     case EM_D30V:
 803     case EM_CYGNUS_D30V:
 804     case EM_FR30:
 805     case EM_FT32:
 806     case EM_CYGNUS_FR30:
 807     case EM_CYGNUS_FRV:
 808     case EM_H8S:
 809     case EM_H8_300:
 810     case EM_H8_300H:
 811     case EM_IA_64:
 812     case EM_IP2K:
 813     case EM_IP2K_OLD:
 814     case EM_IQ2000:
 815     case EM_LATTICEMICO32:
 816     case EM_M32C_OLD:
 817     case EM_M32C:
 818     case EM_M32R:
 819     case EM_MCORE:
 820     case EM_CYGNUS_MEP:
 821     case EM_METAG:
 822     case EM_MMIX:
 823     case EM_MN10200:
 824     case EM_CYGNUS_MN10200:
 825     case EM_MN10300:
 826     case EM_CYGNUS_MN10300:
 827     case EM_MOXIE:
 828     case EM_MSP430:
 829     case EM_MSP430_OLD:
 830     case EM_MT:
 831     case EM_NDS32:
 832     case EM_NIOS32:
 833     case EM_OR1K:
 834     case EM_PPC64:
 835     case EM_PPC:
 836     case EM_TI_PRU:
 837     case EM_RISCV:
 838     case EM_RL78:
 839     case EM_RX:
 840     case EM_S390:
 841     case EM_S390_OLD:
 842     case EM_SH:
 843     case EM_SPARC:
 844     case EM_SPARC32PLUS:
 845     case EM_SPARCV9:
 846     case EM_SPU:
 847     case EM_TI_C6000:
 848     case EM_TILEGX:
 849     case EM_TILEPRO:
 850     case EM_V800:
 851     case EM_V850:
 852     case EM_CYGNUS_V850:
 853     case EM_VAX:
 854     case EM_VISIUM:
 855     case EM_X86_64:
 856     case EM_L1OM:
 857     case EM_K1OM:
 858     case EM_XSTORMY16:
 859     case EM_XTENSA:
 860     case EM_XTENSA_OLD:
 861     case EM_MICROBLAZE:
 862     case EM_MICROBLAZE_OLD:
 863     case EM_WEBASSEMBLY:
 864       return TRUE;
 865
 866     case EM_68HC05:
 867     case EM_68HC08:
 868     case EM_68HC11:
 869     case EM_68HC16:
 870     case EM_FX66:
 871     case EM_ME16:
 872     case EM_MMA:
 873     case EM_NCPU:
 874     case EM_NDR1:
 875     case EM_PCP:
 876     case EM_ST100:
 877     case EM_ST19:
 878     case EM_ST7:
 879     case EM_ST9PLUS:
 880     case EM_STARCORE:
 881     case EM_SVX:
 882     case EM_TINYJ:
 883     default:
 884       warn (_("Don't know about relocations on this machine architecture\n"));
 885       return FALSE;
 886     }
 887 }
 888
 889 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 890    Returns TRUE upon success, FALSE otherwise.  If successful then a
 891    pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
 892    and the number of relocs loaded is placed in *NRELASP.  It is the caller's
 893    responsibility to free the allocated buffer.  */
 894
 895 static bfd_boolean
 896 slurp_rela_relocs (Filedata *            filedata,
 897                    unsigned long         rel_offset,
 898                    unsigned long         rel_size,
 899                    Elf_Internal_Rela **  relasp,
 900                    unsigned long *       nrelasp)
 901 {
 902   Elf_Internal_Rela * relas;
 903   size_t nrelas;
 904   unsigned int i;
 905
 906   if (is_32bit_elf)
 907     {
 908       Elf32_External_Rela * erelas;
 909
 910       erelas = (Elf32_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 911                                                  rel_size, _("32-bit relocation data"));
 912       if (!erelas)
 913         return FALSE;
 914
 915       nrelas = rel_size / sizeof (Elf32_External_Rela);
 916
 917       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 918                                              sizeof (Elf_Internal_Rela));
 919
 920       if (relas == NULL)
 921         {
 922           free (erelas);
 923           error (_("out of memory parsing relocs\n"));
 924           return FALSE;
 925         }
 926
 927       for (i = 0; i < nrelas; i++)
 928         {
 929           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 930           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 931           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 932         }
 933
 934       free (erelas);
 935     }
 936   else
 937     {
 938       Elf64_External_Rela * erelas;
 939
 940       erelas = (Elf64_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 941                                                  rel_size, _("64-bit relocation data"));
 942       if (!erelas)
 943         return FALSE;
 944
 945       nrelas = rel_size / sizeof (Elf64_External_Rela);
 946
 947       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 948                                              sizeof (Elf_Internal_Rela));
 949
 950       if (relas == NULL)
 951         {
 952           free (erelas);
 953           error (_("out of memory parsing relocs\n"));
 954           return FALSE;
 955         }
 956
 957       for (i = 0; i < nrelas; i++)
 958         {
 959           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 960           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 961           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 962
 963           /* The #ifdef BFD64 below is to prevent a compile time
 964              warning.  We know that if we do not have a 64 bit data
 965              type that we will never execute this code anyway.  */
 966 #ifdef BFD64
 967           if (filedata->file_header.e_machine == EM_MIPS
 968               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
 969             {
 970               /* In little-endian objects, r_info isn't really a
 971                  64-bit little-endian value: it has a 32-bit
 972                  little-endian symbol index followed by four
 973                  individual byte fields.  Reorder INFO
 974                  accordingly.  */
 975               bfd_vma inf = relas[i].r_info;
 976               inf = (((inf & 0xffffffff) << 32)
 977                       | ((inf >> 56) & 0xff)
 978                       | ((inf >> 40) & 0xff00)
 979                       | ((inf >> 24) & 0xff0000)
 980                       | ((inf >> 8) & 0xff000000));
 981               relas[i].r_info = inf;
 982             }
 983 #endif /* BFD64 */
 984         }
 985
 986       free (erelas);
 987     }
 988
 989   *relasp = relas;
 990   *nrelasp = nrelas;
 991   return TRUE;
 992 }
 993
 994 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 995    Returns TRUE upon success, FALSE otherwise.  If successful then a
 996    pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
 997    and the number of relocs loaded is placed in *NRELSP.  It is the caller's
 998    responsibility to free the allocated buffer.  */
 999
1000 static bfd_boolean
1001 slurp_rel_relocs (Filedata *            filedata,
1002                   unsigned long         rel_offset,
1003                   unsigned long         rel_size,
1004                   Elf_Internal_Rela **  relsp,
1005                   unsigned long *       nrelsp)
1006 {
1007   Elf_Internal_Rela * rels;
1008   size_t nrels;
1009   unsigned int i;
1010
1011   if (is_32bit_elf)
1012     {
1013       Elf32_External_Rel * erels;
1014
1015       erels = (Elf32_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1016                                                rel_size, _("32-bit relocation data"));
1017       if (!erels)
1018         return FALSE;
1019
1020       nrels = rel_size / sizeof (Elf32_External_Rel);
1021
1022       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1023
1024       if (rels == NULL)
1025         {
1026           free (erels);
1027           error (_("out of memory parsing relocs\n"));
1028           return FALSE;
1029         }
1030
1031       for (i = 0; i < nrels; i++)
1032         {
1033           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1034           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1035           rels[i].r_addend = 0;
1036         }
1037
1038       free (erels);
1039     }
1040   else
1041     {
1042       Elf64_External_Rel * erels;
1043
1044       erels = (Elf64_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1045                                                rel_size, _("64-bit relocation data"));
1046       if (!erels)
1047         return FALSE;
1048
1049       nrels = rel_size / sizeof (Elf64_External_Rel);
1050
1051       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1052
1053       if (rels == NULL)
1054         {
1055           free (erels);
1056           error (_("out of memory parsing relocs\n"));
1057           return FALSE;
1058         }
1059
1060       for (i = 0; i < nrels; i++)
1061         {
1062           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1063           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1064           rels[i].r_addend = 0;
1065
1066           /* The #ifdef BFD64 below is to prevent a compile time
1067              warning.  We know that if we do not have a 64 bit data
1068              type that we will never execute this code anyway.  */
1069 #ifdef BFD64
1070           if (filedata->file_header.e_machine == EM_MIPS
1071               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
1072             {
1073               /* In little-endian objects, r_info isn't really a
1074                  64-bit little-endian value: it has a 32-bit
1075                  little-endian symbol index followed by four
1076                  individual byte fields.  Reorder INFO
1077                  accordingly.  */
1078               bfd_vma inf = rels[i].r_info;
1079               inf = (((inf & 0xffffffff) << 32)
1080                      | ((inf >> 56) & 0xff)
1081                      | ((inf >> 40) & 0xff00)
1082                      | ((inf >> 24) & 0xff0000)
1083                      | ((inf >> 8) & 0xff000000));
1084               rels[i].r_info = inf;
1085             }
1086 #endif /* BFD64 */
1087         }
1088
1089       free (erels);
1090     }
1091
1092   *relsp = rels;
1093   *nrelsp = nrels;
1094   return TRUE;
1095 }
1096
1097 /* Returns the reloc type extracted from the reloc info field.  */
1098
1099 static unsigned int
1100 get_reloc_type (Filedata * filedata, bfd_vma reloc_info)
1101 {
1102   if (is_32bit_elf)
1103     return ELF32_R_TYPE (reloc_info);
1104
1105   switch (filedata->file_header.e_machine)
1106     {
1107     case EM_MIPS:
1108       /* Note: We assume that reloc_info has already been adjusted for us.  */
1109       return ELF64_MIPS_R_TYPE (reloc_info);
1110
1111     case EM_SPARCV9:
1112       return ELF64_R_TYPE_ID (reloc_info);
1113
1114     default:
1115       return ELF64_R_TYPE (reloc_info);
1116     }
1117 }
1118
1119 /* Return the symbol index extracted from the reloc info field.  */
1120
1121 static bfd_vma
1122 get_reloc_symindex (bfd_vma reloc_info)
1123 {
1124   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1125 }
1126
1127 static inline bfd_boolean
1128 uses_msp430x_relocs (Filedata * filedata)
1129 {
1130   return
1131     filedata->file_header.e_machine == EM_MSP430 /* Paranoia.  */
1132     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
1133     && (((filedata->file_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1134         /* TI compiler uses ELFOSABI_NONE.  */
1135         || (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1136 }
1137
1138 /* Display the contents of the relocation data found at the specified
1139    offset.  */
1140
1141 static bfd_boolean
1142 dump_relocations (Filedata *          filedata,
1143                   unsigned long       rel_offset,
1144                   unsigned long       rel_size,
1145                   Elf_Internal_Sym *  symtab,
1146                   unsigned long       nsyms,
1147                   char *              strtab,
1148                   unsigned long       strtablen,
1149                   int                 is_rela,
1150                   bfd_boolean         is_dynsym)
1151 {
1152   unsigned long i;
1153   Elf_Internal_Rela * rels;
1154   bfd_boolean res = TRUE;
1155
1156   if (is_rela == UNKNOWN)
1157     is_rela = guess_is_rela (filedata->file_header.e_machine);
1158
1159   if (is_rela)
1160     {
1161       if (!slurp_rela_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1162         return FALSE;
1163     }
1164   else
1165     {
1166       if (!slurp_rel_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1167         return FALSE;
1168     }
1169
1170   if (is_32bit_elf)
1171     {
1172       if (is_rela)
1173         {
1174           if (do_wide)
1175             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
1176           else
1177             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
1178         }
1179       else
1180         {
1181           if (do_wide)
1182             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
1183           else
1184             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
1185         }
1186     }
1187   else
1188     {
1189       if (is_rela)
1190         {
1191           if (do_wide)
1192             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
1193           else
1194             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
1195         }
1196       else
1197         {
1198           if (do_wide)
1199             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
1200           else
1201             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
1202         }
1203     }
1204
1205   for (i = 0; i < rel_size; i++)
1206     {
1207       const char * rtype;
1208       bfd_vma offset;
1209       bfd_vma inf;
1210       bfd_vma symtab_index;
1211       bfd_vma type;
1212
1213       offset = rels[i].r_offset;
1214       inf    = rels[i].r_info;
1215
1216       type = get_reloc_type (filedata, inf);
1217       symtab_index = get_reloc_symindex  (inf);
1218
1219       if (is_32bit_elf)
1220         {
1221           printf ("%8.8lx  %8.8lx ",
1222                   (unsigned long) offset & 0xffffffff,
1223                   (unsigned long) inf & 0xffffffff);
1224         }
1225       else
1226         {
1227 #if BFD_HOST_64BIT_LONG
1228           printf (do_wide
1229                   ? "%16.16lx  %16.16lx "
1230                   : "%12.12lx  %12.12lx ",
1231                   offset, inf);
1232 #elif BFD_HOST_64BIT_LONG_LONG
1233 #ifndef __MSVCRT__
1234           printf (do_wide
1235                   ? "%16.16llx  %16.16llx "
1236                   : "%12.12llx  %12.12llx ",
1237                   offset, inf);
1238 #else
1239           printf (do_wide
1240                   ? "%16.16I64x  %16.16I64x "
1241                   : "%12.12I64x  %12.12I64x ",
1242                   offset, inf);
1243 #endif
1244 #else
1245           printf (do_wide
1246                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1247                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1248                   _bfd_int64_high (offset),
1249                   _bfd_int64_low (offset),
1250                   _bfd_int64_high (inf),
1251                   _bfd_int64_low (inf));
1252 #endif
1253         }
1254
1255       switch (filedata->file_header.e_machine)
1256         {
1257         default:
1258           rtype = NULL;
1259           break;
1260
1261         case EM_AARCH64:
1262           rtype = elf_aarch64_reloc_type (type);
1263           break;
1264
1265         case EM_M32R:
1266         case EM_CYGNUS_M32R:
1267           rtype = elf_m32r_reloc_type (type);
1268           break;
1269
1270         case EM_386:
1271         case EM_IAMCU:
1272           rtype = elf_i386_reloc_type (type);
1273           break;
1274
1275         case EM_68HC11:
1276         case EM_68HC12:
1277           rtype = elf_m68hc11_reloc_type (type);
1278           break;
1279
1280         case EM_S12Z:
1281           rtype = elf_s12z_reloc_type (type);
1282           break;
1283
1284         case EM_68K:
1285           rtype = elf_m68k_reloc_type (type);
1286           break;
1287
1288         case EM_960:
1289           rtype = elf_i960_reloc_type (type);
1290           break;
1291
1292         case EM_AVR:
1293         case EM_AVR_OLD:
1294           rtype = elf_avr_reloc_type (type);
1295           break;
1296
1297         case EM_OLD_SPARCV9:
1298         case EM_SPARC32PLUS:
1299         case EM_SPARCV9:
1300         case EM_SPARC:
1301           rtype = elf_sparc_reloc_type (type);
1302           break;
1303
1304         case EM_SPU:
1305           rtype = elf_spu_reloc_type (type);
1306           break;
1307
1308         case EM_V800:
1309           rtype = v800_reloc_type (type);
1310           break;
1311         case EM_V850:
1312         case EM_CYGNUS_V850:
1313           rtype = v850_reloc_type (type);
1314           break;
1315
1316         case EM_D10V:
1317         case EM_CYGNUS_D10V:
1318           rtype = elf_d10v_reloc_type (type);
1319           break;
1320
1321         case EM_D30V:
1322         case EM_CYGNUS_D30V:
1323           rtype = elf_d30v_reloc_type (type);
1324           break;
1325
1326         case EM_DLX:
1327           rtype = elf_dlx_reloc_type (type);
1328           break;
1329
1330         case EM_SH:
1331           rtype = elf_sh_reloc_type (type);
1332           break;
1333
1334         case EM_MN10300:
1335         case EM_CYGNUS_MN10300:
1336           rtype = elf_mn10300_reloc_type (type);
1337           break;
1338
1339         case EM_MN10200:
1340         case EM_CYGNUS_MN10200:
1341           rtype = elf_mn10200_reloc_type (type);
1342           break;
1343
1344         case EM_FR30:
1345         case EM_CYGNUS_FR30:
1346           rtype = elf_fr30_reloc_type (type);
1347           break;
1348
1349         case EM_CYGNUS_FRV:
1350           rtype = elf_frv_reloc_type (type);
1351           break;
1352
1353         case EM_CSKY:
1354           rtype = elf_csky_reloc_type (type);
1355           break;
1356
1357         case EM_FT32:
1358           rtype = elf_ft32_reloc_type (type);
1359           break;
1360
1361         case EM_MCORE:
1362           rtype = elf_mcore_reloc_type (type);
1363           break;
1364
1365         case EM_MMIX:
1366           rtype = elf_mmix_reloc_type (type);
1367           break;
1368
1369         case EM_MOXIE:
1370           rtype = elf_moxie_reloc_type (type);
1371           break;
1372
1373         case EM_MSP430:
1374           if (uses_msp430x_relocs (filedata))
1375             {
1376               rtype = elf_msp430x_reloc_type (type);
1377               break;
1378             }
1379           /* Fall through.  */
1380         case EM_MSP430_OLD:
1381           rtype = elf_msp430_reloc_type (type);
1382           break;
1383
1384         case EM_NDS32:
1385           rtype = elf_nds32_reloc_type (type);
1386           break;
1387
1388         case EM_PPC:
1389           rtype = elf_ppc_reloc_type (type);
1390           break;
1391
1392         case EM_PPC64:
1393           rtype = elf_ppc64_reloc_type (type);
1394           break;
1395
1396         case EM_MIPS:
1397         case EM_MIPS_RS3_LE:
1398           rtype = elf_mips_reloc_type (type);
1399           break;
1400
1401         case EM_RISCV:
1402           rtype = elf_riscv_reloc_type (type);
1403           break;
1404
1405         case EM_ALPHA:
1406           rtype = elf_alpha_reloc_type (type);
1407           break;
1408
1409         case EM_ARM:
1410           rtype = elf_arm_reloc_type (type);
1411           break;
1412
1413         case EM_ARC:
1414         case EM_ARC_COMPACT:
1415         case EM_ARC_COMPACT2:
1416           rtype = elf_arc_reloc_type (type);
1417           break;
1418
1419         case EM_PARISC:
1420           rtype = elf_hppa_reloc_type (type);
1421           break;
1422
1423         case EM_H8_300:
1424         case EM_H8_300H:
1425         case EM_H8S:
1426           rtype = elf_h8_reloc_type (type);
1427           break;
1428
1429         case EM_OR1K:
1430           rtype = elf_or1k_reloc_type (type);
1431           break;
1432
1433         case EM_PJ:
1434         case EM_PJ_OLD:
1435           rtype = elf_pj_reloc_type (type);
1436           break;
1437         case EM_IA_64:
1438           rtype = elf_ia64_reloc_type (type);
1439           break;
1440
1441         case EM_CRIS:
1442           rtype = elf_cris_reloc_type (type);
1443           break;
1444
1445         case EM_860:
1446           rtype = elf_i860_reloc_type (type);
1447           break;
1448
1449         case EM_X86_64:
1450         case EM_L1OM:
1451         case EM_K1OM:
1452           rtype = elf_x86_64_reloc_type (type);
1453           break;
1454
1455         case EM_S370:
1456           rtype = i370_reloc_type (type);
1457           break;
1458
1459         case EM_S390_OLD:
1460         case EM_S390:
1461           rtype = elf_s390_reloc_type (type);
1462           break;
1463
1464         case EM_SCORE:
1465           rtype = elf_score_reloc_type (type);
1466           break;
1467
1468         case EM_XSTORMY16:
1469           rtype = elf_xstormy16_reloc_type (type);
1470           break;
1471
1472         case EM_CRX:
1473           rtype = elf_crx_reloc_type (type);
1474           break;
1475
1476         case EM_VAX:
1477           rtype = elf_vax_reloc_type (type);
1478           break;
1479
1480         case EM_VISIUM:
1481           rtype = elf_visium_reloc_type (type);
1482           break;
1483
1484         case EM_ADAPTEVA_EPIPHANY:
1485           rtype = elf_epiphany_reloc_type (type);
1486           break;
1487
1488         case EM_IP2K:
1489         case EM_IP2K_OLD:
1490           rtype = elf_ip2k_reloc_type (type);
1491           break;
1492
1493         case EM_IQ2000:
1494           rtype = elf_iq2000_reloc_type (type);
1495           break;
1496
1497         case EM_XTENSA_OLD:
1498         case EM_XTENSA:
1499           rtype = elf_xtensa_reloc_type (type);
1500           break;
1501
1502         case EM_LATTICEMICO32:
1503           rtype = elf_lm32_reloc_type (type);
1504           break;
1505
1506         case EM_M32C_OLD:
1507         case EM_M32C:
1508           rtype = elf_m32c_reloc_type (type);
1509           break;
1510
1511         case EM_MT:
1512           rtype = elf_mt_reloc_type (type);
1513           break;
1514
1515         case EM_BLACKFIN:
1516           rtype = elf_bfin_reloc_type (type);
1517           break;
1518
1519         case EM_CYGNUS_MEP:
1520           rtype = elf_mep_reloc_type (type);
1521           break;
1522
1523         case EM_CR16:
1524           rtype = elf_cr16_reloc_type (type);
1525           break;
1526
1527         case EM_MICROBLAZE:
1528         case EM_MICROBLAZE_OLD:
1529           rtype = elf_microblaze_reloc_type (type);
1530           break;
1531
1532         case EM_RL78:
1533           rtype = elf_rl78_reloc_type (type);
1534           break;
1535
1536         case EM_RX:
1537           rtype = elf_rx_reloc_type (type);
1538           break;
1539
1540         case EM_METAG:
1541           rtype = elf_metag_reloc_type (type);
1542           break;
1543
1544         case EM_XC16X:
1545         case EM_C166:
1546           rtype = elf_xc16x_reloc_type (type);
1547           break;
1548
1549         case EM_TI_C6000:
1550           rtype = elf_tic6x_reloc_type (type);
1551           break;
1552
1553         case EM_TILEGX:
1554           rtype = elf_tilegx_reloc_type (type);
1555           break;
1556
1557         case EM_TILEPRO:
1558           rtype = elf_tilepro_reloc_type (type);
1559           break;
1560
1561         case EM_WEBASSEMBLY:
1562           rtype = elf_wasm32_reloc_type (type);
1563           break;
1564
1565         case EM_XGATE:
1566           rtype = elf_xgate_reloc_type (type);
1567           break;
1568
1569         case EM_ALTERA_NIOS2:
1570           rtype = elf_nios2_reloc_type (type);
1571           break;
1572
1573         case EM_TI_PRU:
1574           rtype = elf_pru_reloc_type (type);
1575           break;
1576
1577         case EM_NFP:
1578           if (EF_NFP_MACH (filedata->file_header.e_flags) == E_NFP_MACH_3200)
1579             rtype = elf_nfp3200_reloc_type (type);
1580           else
1581             rtype = elf_nfp_reloc_type (type);
1582           break;
1583         }
1584
1585       if (rtype == NULL)
1586         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1587       else
1588         printf (do_wide ? "%-22s" : "%-17.17s", rtype);
1589
1590       if (filedata->file_header.e_machine == EM_ALPHA
1591           && rtype != NULL
1592           && streq (rtype, "R_ALPHA_LITUSE")
1593           && is_rela)
1594         {
1595           switch (rels[i].r_addend)
1596             {
1597             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1598             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1599             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1600             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1601             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1602             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1603             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1604             default: rtype = NULL;
1605             }
1606
1607           if (rtype)
1608             printf (" (%s)", rtype);
1609           else
1610             {
1611               putchar (' ');
1612               printf (_("<unknown addend: %lx>"),
1613                       (unsigned long) rels[i].r_addend);
1614               res = FALSE;
1615             }
1616         }
1617       else if (symtab_index)
1618         {
1619           if (symtab == NULL || symtab_index >= nsyms)
1620             {
1621               error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1622               res = FALSE;
1623             }
1624           else
1625             {
1626               Elf_Internal_Sym * psym;
1627               const char * version_string;
1628               enum versioned_symbol_info sym_info;
1629               unsigned short vna_other;
1630
1631               psym = symtab + symtab_index;
1632
1633               version_string
1634                 = get_symbol_version_string (filedata, is_dynsym,
1635                                              strtab, strtablen,
1636                                              symtab_index,
1637                                              psym,
1638                                              &sym_info,
1639                                              &vna_other);
1640
1641               printf (" ");
1642
1643               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1644                 {
1645                   const char * name;
1646                   unsigned int len;
1647                   unsigned int width = is_32bit_elf ? 8 : 14;
1648
1649                   /* Relocations against GNU_IFUNC symbols do not use the value
1650                      of the symbol as the address to relocate against.  Instead
1651                      they invoke the function named by the symbol and use its
1652                      result as the address for relocation.
1653
1654                      To indicate this to the user, do not display the value of
1655                      the symbol in the "Symbols's Value" field.  Instead show
1656                      its name followed by () as a hint that the symbol is
1657                      invoked.  */
1658
1659                   if (strtab == NULL
1660                       || psym->st_name == 0
1661                       || psym->st_name >= strtablen)
1662                     name = "??";
1663                   else
1664                     name = strtab + psym->st_name;
1665
1666                   len = print_symbol (width, name);
1667                   if (version_string)
1668                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1669                             version_string);
1670                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1671                 }
1672               else
1673                 {
1674                   print_vma (psym->st_value, LONG_HEX);
1675
1676                   printf (is_32bit_elf ? "   " : " ");
1677                 }
1678
1679               if (psym->st_name == 0)
1680                 {
1681                   const char * sec_name = "<null>";
1682                   char name_buf[40];
1683
1684                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1685                     {
1686                       if (psym->st_shndx < filedata->file_header.e_shnum)
1687                         sec_name = SECTION_NAME (filedata->section_headers + psym->st_shndx);
1688                       else if (psym->st_shndx == SHN_ABS)
1689                         sec_name = "ABS";
1690                       else if (psym->st_shndx == SHN_COMMON)
1691                         sec_name = "COMMON";
1692                       else if ((filedata->file_header.e_machine == EM_MIPS
1693                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1694                                || (filedata->file_header.e_machine == EM_TI_C6000
1695                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1696                         sec_name = "SCOMMON";
1697                       else if (filedata->file_header.e_machine == EM_MIPS
1698                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1699                         sec_name = "SUNDEF";
1700                       else if ((filedata->file_header.e_machine == EM_X86_64
1701                                 || filedata->file_header.e_machine == EM_L1OM
1702                                 || filedata->file_header.e_machine == EM_K1OM)
1703                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1704                         sec_name = "LARGE_COMMON";
1705                       else if (filedata->file_header.e_machine == EM_IA_64
1706                                && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1707                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1708                         sec_name = "ANSI_COM";
1709                       else if (is_ia64_vms (filedata)
1710                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1711                         sec_name = "VMS_SYMVEC";
1712                       else
1713                         {
1714                           sprintf (name_buf, "<section 0x%x>",
1715                                    (unsigned int) psym->st_shndx);
1716                           sec_name = name_buf;
1717                         }
1718                     }
1719                   print_symbol (22, sec_name);
1720                 }
1721               else if (strtab == NULL)
1722                 printf (_("<string table index: %3ld>"), psym->st_name);
1723               else if (psym->st_name >= strtablen)
1724                 {
1725                   error (_("<corrupt string table index: %3ld>"), psym->st_name);
1726                   res = FALSE;
1727                 }
1728               else
1729                 {
1730                   print_symbol (22, strtab + psym->st_name);
1731                   if (version_string)
1732                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1733                             version_string);
1734                 }
1735
1736               if (is_rela)
1737                 {
1738                   bfd_vma off = rels[i].r_addend;
1739
1740                   if ((bfd_signed_vma) off < 0)
1741                     printf (" - %" BFD_VMA_FMT "x", - off);
1742                   else
1743                     printf (" + %" BFD_VMA_FMT "x", off);
1744                 }
1745             }
1746         }
1747       else if (is_rela)
1748         {
1749           bfd_vma off = rels[i].r_addend;
1750
1751           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1752           if ((bfd_signed_vma) off < 0)
1753             printf ("-%" BFD_VMA_FMT "x", - off);
1754           else
1755             printf ("%" BFD_VMA_FMT "x", off);
1756         }
1757
1758       if (filedata->file_header.e_machine == EM_SPARCV9
1759           && rtype != NULL
1760           && streq (rtype, "R_SPARC_OLO10"))
1761         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1762
1763       putchar ('\n');
1764
1765 #ifdef BFD64
1766       if (! is_32bit_elf && filedata->file_header.e_machine == EM_MIPS)
1767         {
1768           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1769           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1770           const char * rtype2 = elf_mips_reloc_type (type2);
1771           const char * rtype3 = elf_mips_reloc_type (type3);
1772
1773           printf ("                    Type2: ");
1774
1775           if (rtype2 == NULL)
1776             printf (_("unrecognized: %-7lx"),
1777                     (unsigned long) type2 & 0xffffffff);
1778           else
1779             printf ("%-17.17s", rtype2);
1780
1781           printf ("\n                    Type3: ");
1782
1783           if (rtype3 == NULL)
1784             printf (_("unrecognized: %-7lx"),
1785                     (unsigned long) type3 & 0xffffffff);
1786           else
1787             printf ("%-17.17s", rtype3);
1788
1789           putchar ('\n');
1790         }
1791 #endif /* BFD64 */
1792     }
1793
1794   free (rels);
1795
1796   return res;
1797 }
1798
1799 static const char *
1800 get_mips_dynamic_type (unsigned long type)
1801 {
1802   switch (type)
1803     {
1804     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1805     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1806     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1807     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1808     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1809     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1810     case DT_MIPS_MSYM: return "MIPS_MSYM";
1811     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1812     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1813     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1814     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1815     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1816     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1817     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1818     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1819     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1820     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1821     case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1822     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1823     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1824     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1825     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1826     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1827     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1828     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1829     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1830     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1831     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1832     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1833     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1834     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1835     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1836     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1837     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1838     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1839     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1840     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1841     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1842     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1843     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1844     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1845     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1846     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1847     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1848     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1849     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1850     default:
1851       return NULL;
1852     }
1853 }
1854
1855 static const char *
1856 get_sparc64_dynamic_type (unsigned long type)
1857 {
1858   switch (type)
1859     {
1860     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1861     default:
1862       return NULL;
1863     }
1864 }
1865
1866 static const char *
1867 get_ppc_dynamic_type (unsigned long type)
1868 {
1869   switch (type)
1870     {
1871     case DT_PPC_GOT:    return "PPC_GOT";
1872     case DT_PPC_OPT:    return "PPC_OPT";
1873     default:
1874       return NULL;
1875     }
1876 }
1877
1878 static const char *
1879 get_ppc64_dynamic_type (unsigned long type)
1880 {
1881   switch (type)
1882     {
1883     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1884     case DT_PPC64_OPD:    return "PPC64_OPD";
1885     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1886     case DT_PPC64_OPT:    return "PPC64_OPT";
1887     default:
1888       return NULL;
1889     }
1890 }
1891
1892 static const char *
1893 get_parisc_dynamic_type (unsigned long type)
1894 {
1895   switch (type)
1896     {
1897     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1898     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1899     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1900     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1901     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1902     case DT_HP_PREINIT:         return "HP_PREINIT";
1903     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1904     case DT_HP_NEEDED:          return "HP_NEEDED";
1905     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1906     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1907     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1908     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1909     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1910     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1911     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1912     case DT_HP_FILTERED:        return "HP_FILTERED";
1913     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1914     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1915     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1916     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1917     case DT_PLT:                return "PLT";
1918     case DT_PLT_SIZE:           return "PLT_SIZE";
1919     case DT_DLT:                return "DLT";
1920     case DT_DLT_SIZE:           return "DLT_SIZE";
1921     default:
1922       return NULL;
1923     }
1924 }
1925
1926 static const char *
1927 get_ia64_dynamic_type (unsigned long type)
1928 {
1929   switch (type)
1930     {
1931     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1932     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1933     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1934     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1935     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1936     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1937     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1938     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1939     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1940     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1941     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1942     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1943     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1944     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1945     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1946     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1947     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1948     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1949     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1950     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1951     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1952     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1953     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1954     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1955     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1956     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1957     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1958     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1959     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1960     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1961     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1962     default:
1963       return NULL;
1964     }
1965 }
1966
1967 static const char *
1968 get_solaris_section_type (unsigned long type)
1969 {
1970   switch (type)
1971     {
1972     case 0x6fffffee: return "SUNW_ancillary";
1973     case 0x6fffffef: return "SUNW_capchain";
1974     case 0x6ffffff0: return "SUNW_capinfo";
1975     case 0x6ffffff1: return "SUNW_symsort";
1976     case 0x6ffffff2: return "SUNW_tlssort";
1977     case 0x6ffffff3: return "SUNW_LDYNSYM";
1978     case 0x6ffffff4: return "SUNW_dof";
1979     case 0x6ffffff5: return "SUNW_cap";
1980     case 0x6ffffff6: return "SUNW_SIGNATURE";
1981     case 0x6ffffff7: return "SUNW_ANNOTATE";
1982     case 0x6ffffff8: return "SUNW_DEBUGSTR";
1983     case 0x6ffffff9: return "SUNW_DEBUG";
1984     case 0x6ffffffa: return "SUNW_move";
1985     case 0x6ffffffb: return "SUNW_COMDAT";
1986     case 0x6ffffffc: return "SUNW_syminfo";
1987     case 0x6ffffffd: return "SUNW_verdef";
1988     case 0x6ffffffe: return "SUNW_verneed";
1989     case 0x6fffffff: return "SUNW_versym";
1990     case 0x70000000: return "SPARC_GOTDATA";
1991     default: return NULL;
1992     }
1993 }
1994
1995 static const char *
1996 get_alpha_dynamic_type (unsigned long type)
1997 {
1998   switch (type)
1999     {
2000     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
2001     default: return NULL;
2002     }
2003 }
2004
2005 static const char *
2006 get_score_dynamic_type (unsigned long type)
2007 {
2008   switch (type)
2009     {
2010     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
2011     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
2012     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
2013     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
2014     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
2015     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
2016     default:                    return NULL;
2017     }
2018 }
2019
2020 static const char *
2021 get_tic6x_dynamic_type (unsigned long type)
2022 {
2023   switch (type)
2024     {
2025     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
2026     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
2027     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
2028     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
2029     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
2030     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
2031     default:                   return NULL;
2032     }
2033 }
2034
2035 static const char *
2036 get_nios2_dynamic_type (unsigned long type)
2037 {
2038   switch (type)
2039     {
2040     case DT_NIOS2_GP: return "NIOS2_GP";
2041     default:          return NULL;
2042     }
2043 }
2044
2045 static const char *
2046 get_solaris_dynamic_type (unsigned long type)
2047 {
2048   switch (type)
2049     {
2050     case 0x6000000d: return "SUNW_AUXILIARY";
2051     case 0x6000000e: return "SUNW_RTLDINF";
2052     case 0x6000000f: return "SUNW_FILTER";
2053     case 0x60000010: return "SUNW_CAP";
2054     case 0x60000011: return "SUNW_SYMTAB";
2055     case 0x60000012: return "SUNW_SYMSZ";
2056     case 0x60000013: return "SUNW_SORTENT";
2057     case 0x60000014: return "SUNW_SYMSORT";
2058     case 0x60000015: return "SUNW_SYMSORTSZ";
2059     case 0x60000016: return "SUNW_TLSSORT";
2060     case 0x60000017: return "SUNW_TLSSORTSZ";
2061     case 0x60000018: return "SUNW_CAPINFO";
2062     case 0x60000019: return "SUNW_STRPAD";
2063     case 0x6000001a: return "SUNW_CAPCHAIN";
2064     case 0x6000001b: return "SUNW_LDMACH";
2065     case 0x6000001d: return "SUNW_CAPCHAINENT";
2066     case 0x6000001f: return "SUNW_CAPCHAINSZ";
2067     case 0x60000021: return "SUNW_PARENT";
2068     case 0x60000023: return "SUNW_ASLR";
2069     case 0x60000025: return "SUNW_RELAX";
2070     case 0x60000029: return "SUNW_NXHEAP";
2071     case 0x6000002b: return "SUNW_NXSTACK";
2072
2073     case 0x70000001: return "SPARC_REGISTER";
2074     case 0x7ffffffd: return "AUXILIARY";
2075     case 0x7ffffffe: return "USED";
2076     case 0x7fffffff: return "FILTER";
2077
2078     default: return NULL;
2079     }
2080 }
2081
2082 static const char *
2083 get_dynamic_type (Filedata * filedata, unsigned long type)
2084 {
2085   static char buff[64];
2086
2087   switch (type)
2088     {
2089     case DT_NULL:       return "NULL";
2090     case DT_NEEDED:     return "NEEDED";
2091     case DT_PLTRELSZ:   return "PLTRELSZ";
2092     case DT_PLTGOT:     return "PLTGOT";
2093     case DT_HASH:       return "HASH";
2094     case DT_STRTAB:     return "STRTAB";
2095     case DT_SYMTAB:     return "SYMTAB";
2096     case DT_RELA:       return "RELA";
2097     case DT_RELASZ:     return "RELASZ";
2098     case DT_RELAENT:    return "RELAENT";
2099     case DT_STRSZ:      return "STRSZ";
2100     case DT_SYMENT:     return "SYMENT";
2101     case DT_INIT:       return "INIT";
2102     case DT_FINI:       return "FINI";
2103     case DT_SONAME:     return "SONAME";
2104     case DT_RPATH:      return "RPATH";
2105     case DT_SYMBOLIC:   return "SYMBOLIC";
2106     case DT_REL:        return "REL";
2107     case DT_RELSZ:      return "RELSZ";
2108     case DT_RELENT:     return "RELENT";
2109     case DT_PLTREL:     return "PLTREL";
2110     case DT_DEBUG:      return "DEBUG";
2111     case DT_TEXTREL:    return "TEXTREL";
2112     case DT_JMPREL:     return "JMPREL";
2113     case DT_BIND_NOW:   return "BIND_NOW";
2114     case DT_INIT_ARRAY: return "INIT_ARRAY";
2115     case DT_FINI_ARRAY: return "FINI_ARRAY";
2116     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2117     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2118     case DT_RUNPATH:    return "RUNPATH";
2119     case DT_FLAGS:      return "FLAGS";
2120
2121     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2122     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2123     case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2124
2125     case DT_CHECKSUM:   return "CHECKSUM";
2126     case DT_PLTPADSZ:   return "PLTPADSZ";
2127     case DT_MOVEENT:    return "MOVEENT";
2128     case DT_MOVESZ:     return "MOVESZ";
2129     case DT_FEATURE:    return "FEATURE";
2130     case DT_POSFLAG_1:  return "POSFLAG_1";
2131     case DT_SYMINSZ:    return "SYMINSZ";
2132     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
2133
2134     case DT_ADDRRNGLO:  return "ADDRRNGLO";
2135     case DT_CONFIG:     return "CONFIG";
2136     case DT_DEPAUDIT:   return "DEPAUDIT";
2137     case DT_AUDIT:      return "AUDIT";
2138     case DT_PLTPAD:     return "PLTPAD";
2139     case DT_MOVETAB:    return "MOVETAB";
2140     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
2141
2142     case DT_VERSYM:     return "VERSYM";
2143
2144     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2145     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2146     case DT_RELACOUNT:  return "RELACOUNT";
2147     case DT_RELCOUNT:   return "RELCOUNT";
2148     case DT_FLAGS_1:    return "FLAGS_1";
2149     case DT_VERDEF:     return "VERDEF";
2150     case DT_VERDEFNUM:  return "VERDEFNUM";
2151     case DT_VERNEED:    return "VERNEED";
2152     case DT_VERNEEDNUM: return "VERNEEDNUM";
2153
2154     case DT_AUXILIARY:  return "AUXILIARY";
2155     case DT_USED:       return "USED";
2156     case DT_FILTER:     return "FILTER";
2157
2158     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2159     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2160     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2161     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2162     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2163     case DT_GNU_HASH:   return "GNU_HASH";
2164
2165     default:
2166       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2167         {
2168           const char * result;
2169
2170           switch (filedata->file_header.e_machine)
2171             {
2172             case EM_MIPS:
2173             case EM_MIPS_RS3_LE:
2174               result = get_mips_dynamic_type (type);
2175               break;
2176             case EM_SPARCV9:
2177               result = get_sparc64_dynamic_type (type);
2178               break;
2179             case EM_PPC:
2180               result = get_ppc_dynamic_type (type);
2181               break;
2182             case EM_PPC64:
2183               result = get_ppc64_dynamic_type (type);
2184               break;
2185             case EM_IA_64:
2186               result = get_ia64_dynamic_type (type);
2187               break;
2188             case EM_ALPHA:
2189               result = get_alpha_dynamic_type (type);
2190               break;
2191             case EM_SCORE:
2192               result = get_score_dynamic_type (type);
2193               break;
2194             case EM_TI_C6000:
2195               result = get_tic6x_dynamic_type (type);
2196               break;
2197             case EM_ALTERA_NIOS2:
2198               result = get_nios2_dynamic_type (type);
2199               break;
2200             default:
2201               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2202                 result = get_solaris_dynamic_type (type);
2203               else
2204                 result = NULL;
2205               break;
2206             }
2207
2208           if (result != NULL)
2209             return result;
2210
2211           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2212         }
2213       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2214                || (filedata->file_header.e_machine == EM_PARISC
2215                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2216         {
2217           const char * result;
2218
2219           switch (filedata->file_header.e_machine)
2220             {
2221             case EM_PARISC:
2222               result = get_parisc_dynamic_type (type);
2223               break;
2224             case EM_IA_64:
2225               result = get_ia64_dynamic_type (type);
2226               break;
2227             default:
2228               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2229                 result = get_solaris_dynamic_type (type);
2230               else
2231                 result = NULL;
2232               break;
2233             }
2234
2235           if (result != NULL)
2236             return result;
2237
2238           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2239                     type);
2240         }
2241       else
2242         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2243
2244       return buff;
2245     }
2246 }
2247
2248 static char *
2249 get_file_type (unsigned e_type)
2250 {
2251   static char buff[32];
2252
2253   switch (e_type)
2254     {
2255     case ET_NONE: return _("NONE (None)");
2256     case ET_REL:  return _("REL (Relocatable file)");
2257     case ET_EXEC: return _("EXEC (Executable file)");
2258     case ET_DYN:  return _("DYN (Shared object file)");
2259     case ET_CORE: return _("CORE (Core file)");
2260
2261     default:
2262       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2263         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2264       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2265         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2266       else
2267         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2268       return buff;
2269     }
2270 }
2271
2272 static char *
2273 get_machine_name (unsigned e_machine)
2274 {
2275   static char buff[64]; /* XXX */
2276
2277   switch (e_machine)
2278     {
2279       /* Please keep this switch table sorted by increasing EM_ value.  */
2280       /* 0 */
2281     case EM_NONE:               return _("None");
2282     case EM_M32:                return "WE32100";
2283     case EM_SPARC:              return "Sparc";
2284     case EM_386:                return "Intel 80386";
2285     case EM_68K:                return "MC68000";
2286     case EM_88K:                return "MC88000";
2287     case EM_IAMCU:              return "Intel MCU";
2288     case EM_860:                return "Intel 80860";
2289     case EM_MIPS:               return "MIPS R3000";
2290     case EM_S370:               return "IBM System/370";
2291       /* 10 */
2292     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
2293     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
2294     case EM_PARISC:             return "HPPA";
2295     case EM_VPP550:             return "Fujitsu VPP500";
2296     case EM_SPARC32PLUS:        return "Sparc v8+" ;
2297     case EM_960:                return "Intel 80960";
2298     case EM_PPC:                return "PowerPC";
2299       /* 20 */
2300     case EM_PPC64:              return "PowerPC64";
2301     case EM_S390_OLD:
2302     case EM_S390:               return "IBM S/390";
2303     case EM_SPU:                return "SPU";
2304       /* 30 */
2305     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
2306     case EM_FR20:               return "Fujitsu FR20";
2307     case EM_RH32:               return "TRW RH32";
2308     case EM_MCORE:              return "MCORE";
2309       /* 40 */
2310     case EM_ARM:                return "ARM";
2311     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
2312     case EM_SH:                 return "Renesas / SuperH SH";
2313     case EM_SPARCV9:            return "Sparc v9";
2314     case EM_TRICORE:            return "Siemens Tricore";
2315     case EM_ARC:                return "ARC";
2316     case EM_H8_300:             return "Renesas H8/300";
2317     case EM_H8_300H:            return "Renesas H8/300H";
2318     case EM_H8S:                return "Renesas H8S";
2319     case EM_H8_500:             return "Renesas H8/500";
2320       /* 50 */
2321     case EM_IA_64:              return "Intel IA-64";
2322     case EM_MIPS_X:             return "Stanford MIPS-X";
2323     case EM_COLDFIRE:           return "Motorola Coldfire";
2324     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
2325     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
2326     case EM_PCP:                return "Siemens PCP";
2327     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
2328     case EM_NDR1:               return "Denso NDR1 microprocesspr";
2329     case EM_STARCORE:           return "Motorola Star*Core processor";
2330     case EM_ME16:               return "Toyota ME16 processor";
2331       /* 60 */
2332     case EM_ST100:              return "STMicroelectronics ST100 processor";
2333     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
2334     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2335     case EM_PDSP:               return "Sony DSP processor";
2336     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
2337     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
2338     case EM_FX66:               return "Siemens FX66 microcontroller";
2339     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2340     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
2341     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
2342       /* 70 */
2343     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
2344     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
2345     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
2346     case EM_SVX:                return "Silicon Graphics SVx";
2347     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
2348     case EM_VAX:                return "Digital VAX";
2349     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
2350     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
2351     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2352     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2353       /* 80 */
2354     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2355     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2356     case EM_PRISM:              return "Vitesse Prism";
2357     case EM_AVR_OLD:
2358     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
2359     case EM_CYGNUS_FR30:
2360     case EM_FR30:               return "Fujitsu FR30";
2361     case EM_CYGNUS_D10V:
2362     case EM_D10V:               return "d10v";
2363     case EM_CYGNUS_D30V:
2364     case EM_D30V:               return "d30v";
2365     case EM_CYGNUS_V850:
2366     case EM_V850:               return "Renesas V850";
2367     case EM_CYGNUS_M32R:
2368     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
2369     case EM_CYGNUS_MN10300:
2370     case EM_MN10300:            return "mn10300";
2371       /* 90 */
2372     case EM_CYGNUS_MN10200:
2373     case EM_MN10200:            return "mn10200";
2374     case EM_PJ:                 return "picoJava";
2375     case EM_OR1K:               return "OpenRISC 1000";
2376     case EM_ARC_COMPACT:        return "ARCompact";
2377     case EM_XTENSA_OLD:
2378     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2379     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2380     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2381     case EM_NS32K:              return "National Semiconductor 32000 series";
2382     case EM_TPC:                return "Tenor Network TPC processor";
2383     case EM_SNP1K:              return "Trebia SNP 1000 processor";
2384       /* 100 */
2385     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2386     case EM_IP2K_OLD:
2387     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2388     case EM_MAX:                return "MAX Processor";
2389     case EM_CR:                 return "National Semiconductor CompactRISC";
2390     case EM_F2MC16:             return "Fujitsu F2MC16";
2391     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2392     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2393     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2394     case EM_SEP:                return "Sharp embedded microprocessor";
2395     case EM_ARCA:               return "Arca RISC microprocessor";
2396       /* 110 */
2397     case EM_UNICORE:            return "Unicore";
2398     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2399     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2400     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2401     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2402     case EM_XGATE:              return "Motorola XGATE embedded processor";
2403     case EM_C166:
2404     case EM_XC16X:              return "Infineon Technologies xc16x";
2405     case EM_M16C:               return "Renesas M16C series microprocessors";
2406     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2407     case EM_CE:                 return "Freescale Communication Engine RISC core";
2408       /* 120 */
2409     case EM_M32C:               return "Renesas M32c";
2410       /* 130 */
2411     case EM_TSK3000:            return "Altium TSK3000 core";
2412     case EM_RS08:               return "Freescale RS08 embedded processor";
2413     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2414     case EM_SCORE:              return "SUNPLUS S+Core";
2415     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2416     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2417     case EM_LATTICEMICO32:      return "Lattice Mico32";
2418     case EM_SE_C17:             return "Seiko Epson C17 family";
2419       /* 140 */
2420     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2421     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2422     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2423     case EM_TI_PRU:             return "TI PRU I/O processor";
2424       /* 160 */
2425     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2426     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2427     case EM_R32C:               return "Renesas R32C series microprocessors";
2428     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2429     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2430     case EM_8051:               return "Intel 8051 and variants";
2431     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2432     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2433     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2434     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2435       /* 170 */
2436     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2437     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2438     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2439     case EM_RX:                 return "Renesas RX";
2440     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2441     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2442     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2443     case EM_CR16:
2444     case EM_MICROBLAZE:
2445     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2446     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2447     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2448       /* 180 */
2449     case EM_L1OM:               return "Intel L1OM";
2450     case EM_K1OM:               return "Intel K1OM";
2451     case EM_INTEL182:           return "Intel (reserved)";
2452     case EM_AARCH64:            return "AArch64";
2453     case EM_ARM184:             return "ARM (reserved)";
2454     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor";
2455     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2456     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2457     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2458       /* 190 */
2459     case EM_CUDA:               return "NVIDIA CUDA architecture";
2460     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2461     case EM_CLOUDSHIELD:        return "CloudShield architecture family";
2462     case EM_COREA_1ST:          return "KIPO-KAIST Core-A 1st generation processor family";
2463     case EM_COREA_2ND:          return "KIPO-KAIST Core-A 2nd generation processor family";
2464     case EM_ARC_COMPACT2:       return "ARCv2";
2465     case EM_OPEN8:              return "Open8 8-bit RISC soft processor core";
2466     case EM_RL78:               return "Renesas RL78";
2467     case EM_VIDEOCORE5:         return "Broadcom VideoCore V processor";
2468     case EM_78K0R:              return "Renesas 78K0R";
2469       /* 200 */
2470     case EM_56800EX:            return "Freescale 56800EX Digital Signal Controller (DSC)";
2471     case EM_BA1:                return "Beyond BA1 CPU architecture";
2472     case EM_BA2:                return "Beyond BA2 CPU architecture";
2473     case EM_XCORE:              return "XMOS xCORE processor family";
2474     case EM_MCHP_PIC:           return "Microchip 8-bit PIC(r) family";
2475       /* 210 */
2476     case EM_KM32:               return "KM211 KM32 32-bit processor";
2477     case EM_KMX32:              return "KM211 KMX32 32-bit processor";
2478     case EM_KMX16:              return "KM211 KMX16 16-bit processor";
2479     case EM_KMX8:               return "KM211 KMX8 8-bit processor";
2480     case EM_KVARC:              return "KM211 KVARC processor";
2481     case EM_CDP:                return "Paneve CDP architecture family";
2482     case EM_COGE:               return "Cognitive Smart Memory Processor";
2483     case EM_COOL:               return "Bluechip Systems CoolEngine";
2484     case EM_NORC:               return "Nanoradio Optimized RISC";
2485     case EM_CSR_KALIMBA:        return "CSR Kalimba architecture family";
2486       /* 220 */
2487     case EM_Z80:                return "Zilog Z80";
2488     case EM_VISIUM:             return "CDS VISIUMcore processor";
2489     case EM_FT32:               return "FTDI Chip FT32";
2490     case EM_MOXIE:              return "Moxie";
2491     case EM_AMDGPU:             return "AMD GPU";
2492     case EM_RISCV:              return "RISC-V";
2493     case EM_LANAI:              return "Lanai 32-bit processor";
2494     case EM_BPF:                return "Linux BPF";
2495     case EM_NFP:                return "Netronome Flow Processor";
2496
2497       /* Large numbers...  */
2498     case EM_MT:                 return "Morpho Techologies MT processor";
2499     case EM_ALPHA:              return "Alpha";
2500     case EM_WEBASSEMBLY:        return "Web Assembly";
2501     case EM_DLX:                return "OpenDLX";
2502     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2503     case EM_IQ2000:             return "Vitesse IQ2000";
2504     case EM_M32C_OLD:
2505     case EM_NIOS32:             return "Altera Nios";
2506     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2507     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2508     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
2509     case EM_S12Z:               return "Freescale S12Z";
2510     case EM_CSKY:               return "C-SKY";
2511
2512     default:
2513       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2514       return buff;
2515     }
2516 }
2517
2518 static void
2519 decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2520 {
2521   /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2.  Some
2522      other compilers don't a specific architecture type in the e_flags, and
2523      instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2524      architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2525      architectures.
2526
2527      Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2528      but also sets a specific architecture type in the e_flags field.
2529
2530      However, when decoding the flags we don't worry if we see an
2531      unexpected pairing, for example EM_ARC_COMPACT machine type, with
2532      ARCEM architecture type.  */
2533
2534   switch (e_flags & EF_ARC_MACH_MSK)
2535     {
2536       /* We only expect these to occur for EM_ARC_COMPACT2.  */
2537     case EF_ARC_CPU_ARCV2EM:
2538       strcat (buf, ", ARC EM");
2539       break;
2540     case EF_ARC_CPU_ARCV2HS:
2541       strcat (buf, ", ARC HS");
2542       break;
2543
2544       /* We only expect these to occur for EM_ARC_COMPACT.  */
2545     case E_ARC_MACH_ARC600:
2546       strcat (buf, ", ARC600");
2547       break;
2548     case E_ARC_MACH_ARC601:
2549       strcat (buf, ", ARC601");
2550       break;
2551     case E_ARC_MACH_ARC700:
2552       strcat (buf, ", ARC700");
2553       break;
2554
2555       /* The only times we should end up here are (a) A corrupt ELF, (b) A
2556          new ELF with new architecture being read by an old version of
2557          readelf, or (c) An ELF built with non-GNU compiler that does not
2558          set the architecture in the e_flags.  */
2559     default:
2560       if (e_machine == EM_ARC_COMPACT)
2561         strcat (buf, ", Unknown ARCompact");
2562       else
2563         strcat (buf, ", Unknown ARC");
2564       break;
2565     }
2566
2567   switch (e_flags & EF_ARC_OSABI_MSK)
2568     {
2569     case E_ARC_OSABI_ORIG:
2570       strcat (buf, ", (ABI:legacy)");
2571       break;
2572     case E_ARC_OSABI_V2:
2573       strcat (buf, ", (ABI:v2)");
2574       break;
2575       /* Only upstream 3.9+ kernels will support ARCv2 ISA.  */
2576     case E_ARC_OSABI_V3:
2577       strcat (buf, ", v3 no-legacy-syscalls ABI");
2578       break;
2579     case E_ARC_OSABI_V4:
2580       strcat (buf, ", v4 ABI");
2581       break;
2582     default:
2583       strcat (buf, ", unrecognised ARC OSABI flag");
2584       break;
2585     }
2586 }
2587
2588 static void
2589 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2590 {
2591   unsigned eabi;
2592   bfd_boolean unknown = FALSE;
2593
2594   eabi = EF_ARM_EABI_VERSION (e_flags);
2595   e_flags &= ~ EF_ARM_EABIMASK;
2596
2597   /* Handle "generic" ARM flags.  */
2598   if (e_flags & EF_ARM_RELEXEC)
2599     {
2600       strcat (buf, ", relocatable executable");
2601       e_flags &= ~ EF_ARM_RELEXEC;
2602     }
2603
2604   if (e_flags & EF_ARM_PIC)
2605     {
2606       strcat (buf, ", position independent");
2607       e_flags &= ~ EF_ARM_PIC;
2608     }
2609
2610   /* Now handle EABI specific flags.  */
2611   switch (eabi)
2612     {
2613     default:
2614       strcat (buf, ", <unrecognized EABI>");
2615       if (e_flags)
2616         unknown = TRUE;
2617       break;
2618
2619     case EF_ARM_EABI_VER1:
2620       strcat (buf, ", Version1 EABI");
2621       while (e_flags)
2622         {
2623           unsigned flag;
2624
2625           /* Process flags one bit at a time.  */
2626           flag = e_flags & - e_flags;
2627           e_flags &= ~ flag;
2628
2629           switch (flag)
2630             {
2631             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2632               strcat (buf, ", sorted symbol tables");
2633               break;
2634
2635             default:
2636               unknown = TRUE;
2637               break;
2638             }
2639         }
2640       break;
2641
2642     case EF_ARM_EABI_VER2:
2643       strcat (buf, ", Version2 EABI");
2644       while (e_flags)
2645         {
2646           unsigned flag;
2647
2648           /* Process flags one bit at a time.  */
2649           flag = e_flags & - e_flags;
2650           e_flags &= ~ flag;
2651
2652           switch (flag)
2653             {
2654             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2655               strcat (buf, ", sorted symbol tables");
2656               break;
2657
2658             case EF_ARM_DYNSYMSUSESEGIDX:
2659               strcat (buf, ", dynamic symbols use segment index");
2660               break;
2661
2662             case EF_ARM_MAPSYMSFIRST:
2663               strcat (buf, ", mapping symbols precede others");
2664               break;
2665
2666             default:
2667               unknown = TRUE;
2668               break;
2669             }
2670         }
2671       break;
2672
2673     case EF_ARM_EABI_VER3:
2674       strcat (buf, ", Version3 EABI");
2675       break;
2676
2677     case EF_ARM_EABI_VER4:
2678       strcat (buf, ", Version4 EABI");
2679       while (e_flags)
2680         {
2681           unsigned flag;
2682
2683           /* Process flags one bit at a time.  */
2684           flag = e_flags & - e_flags;
2685           e_flags &= ~ flag;
2686
2687           switch (flag)
2688             {
2689             case EF_ARM_BE8:
2690               strcat (buf, ", BE8");
2691               break;
2692
2693             case EF_ARM_LE8:
2694               strcat (buf, ", LE8");
2695               break;
2696
2697             default:
2698               unknown = TRUE;
2699               break;
2700             }
2701         }
2702       break;
2703
2704     case EF_ARM_EABI_VER5:
2705       strcat (buf, ", Version5 EABI");
2706       while (e_flags)
2707         {
2708           unsigned flag;
2709
2710           /* Process flags one bit at a time.  */
2711           flag = e_flags & - e_flags;
2712           e_flags &= ~ flag;
2713
2714           switch (flag)
2715             {
2716             case EF_ARM_BE8:
2717               strcat (buf, ", BE8");
2718               break;
2719
2720             case EF_ARM_LE8:
2721               strcat (buf, ", LE8");
2722               break;
2723
2724             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2725               strcat (buf, ", soft-float ABI");
2726               break;
2727
2728             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2729               strcat (buf, ", hard-float ABI");
2730               break;
2731
2732             default:
2733               unknown = TRUE;
2734               break;
2735             }
2736         }
2737       break;
2738
2739     case EF_ARM_EABI_UNKNOWN:
2740       strcat (buf, ", GNU EABI");
2741       while (e_flags)
2742         {
2743           unsigned flag;
2744
2745           /* Process flags one bit at a time.  */
2746           flag = e_flags & - e_flags;
2747           e_flags &= ~ flag;
2748
2749           switch (flag)
2750             {
2751             case EF_ARM_INTERWORK:
2752               strcat (buf, ", interworking enabled");
2753               break;
2754
2755             case EF_ARM_APCS_26:
2756               strcat (buf, ", uses APCS/26");
2757               break;
2758
2759             case EF_ARM_APCS_FLOAT:
2760               strcat (buf, ", uses APCS/float");
2761               break;
2762
2763             case EF_ARM_PIC:
2764               strcat (buf, ", position independent");
2765               break;
2766
2767             case EF_ARM_ALIGN8:
2768               strcat (buf, ", 8 bit structure alignment");
2769               break;
2770
2771             case EF_ARM_NEW_ABI:
2772               strcat (buf, ", uses new ABI");
2773               break;
2774
2775             case EF_ARM_OLD_ABI:
2776               strcat (buf, ", uses old ABI");
2777               break;
2778
2779             case EF_ARM_SOFT_FLOAT:
2780               strcat (buf, ", software FP");
2781               break;
2782
2783             case EF_ARM_VFP_FLOAT:
2784               strcat (buf, ", VFP");
2785               break;
2786
2787             case EF_ARM_MAVERICK_FLOAT:
2788               strcat (buf, ", Maverick FP");
2789               break;
2790
2791             default:
2792               unknown = TRUE;
2793               break;
2794             }
2795         }
2796     }
2797
2798   if (unknown)
2799     strcat (buf,_(", <unknown>"));
2800 }
2801
2802 static void
2803 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2804 {
2805   --size; /* Leave space for null terminator.  */
2806
2807   switch (e_flags & EF_AVR_MACH)
2808     {
2809     case E_AVR_MACH_AVR1:
2810       strncat (buf, ", avr:1", size);
2811       break;
2812     case E_AVR_MACH_AVR2:
2813       strncat (buf, ", avr:2", size);
2814       break;
2815     case E_AVR_MACH_AVR25:
2816       strncat (buf, ", avr:25", size);
2817       break;
2818     case E_AVR_MACH_AVR3:
2819       strncat (buf, ", avr:3", size);
2820       break;
2821     case E_AVR_MACH_AVR31:
2822       strncat (buf, ", avr:31", size);
2823       break;
2824     case E_AVR_MACH_AVR35:
2825       strncat (buf, ", avr:35", size);
2826       break;
2827     case E_AVR_MACH_AVR4:
2828       strncat (buf, ", avr:4", size);
2829       break;
2830     case E_AVR_MACH_AVR5:
2831       strncat (buf, ", avr:5", size);
2832       break;
2833     case E_AVR_MACH_AVR51:
2834       strncat (buf, ", avr:51", size);
2835       break;
2836     case E_AVR_MACH_AVR6:
2837       strncat (buf, ", avr:6", size);
2838       break;
2839     case E_AVR_MACH_AVRTINY:
2840       strncat (buf, ", avr:100", size);
2841       break;
2842     case E_AVR_MACH_XMEGA1:
2843       strncat (buf, ", avr:101", size);
2844       break;
2845     case E_AVR_MACH_XMEGA2:
2846       strncat (buf, ", avr:102", size);
2847       break;
2848     case E_AVR_MACH_XMEGA3:
2849       strncat (buf, ", avr:103", size);
2850       break;
2851     case E_AVR_MACH_XMEGA4:
2852       strncat (buf, ", avr:104", size);
2853       break;
2854     case E_AVR_MACH_XMEGA5:
2855       strncat (buf, ", avr:105", size);
2856       break;
2857     case E_AVR_MACH_XMEGA6:
2858       strncat (buf, ", avr:106", size);
2859       break;
2860     case E_AVR_MACH_XMEGA7:
2861       strncat (buf, ", avr:107", size);
2862       break;
2863     default:
2864       strncat (buf, ", avr:<unknown>", size);
2865       break;
2866     }
2867
2868   size -= strlen (buf);
2869   if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2870     strncat (buf, ", link-relax", size);
2871 }
2872
2873 static void
2874 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2875 {
2876   unsigned abi;
2877   unsigned arch;
2878   unsigned config;
2879   unsigned version;
2880   bfd_boolean has_fpu = FALSE;
2881   unsigned int r = 0;
2882
2883   static const char *ABI_STRINGS[] =
2884   {
2885     "ABI v0", /* use r5 as return register; only used in N1213HC */
2886     "ABI v1", /* use r0 as return register */
2887     "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2888     "ABI v2fp", /* for FPU */
2889     "AABI",
2890     "ABI2 FP+"
2891   };
2892   static const char *VER_STRINGS[] =
2893   {
2894     "Andes ELF V1.3 or older",
2895     "Andes ELF V1.3.1",
2896     "Andes ELF V1.4"
2897   };
2898   static const char *ARCH_STRINGS[] =
2899   {
2900     "",
2901     "Andes Star v1.0",
2902     "Andes Star v2.0",
2903     "Andes Star v3.0",
2904     "Andes Star v3.0m"
2905   };
2906
2907   abi = EF_NDS_ABI & e_flags;
2908   arch = EF_NDS_ARCH & e_flags;
2909   config = EF_NDS_INST & e_flags;
2910   version = EF_NDS32_ELF_VERSION & e_flags;
2911
2912   memset (buf, 0, size);
2913
2914   switch (abi)
2915     {
2916     case E_NDS_ABI_V0:
2917     case E_NDS_ABI_V1:
2918     case E_NDS_ABI_V2:
2919     case E_NDS_ABI_V2FP:
2920     case E_NDS_ABI_AABI:
2921     case E_NDS_ABI_V2FP_PLUS:
2922       /* In case there are holes in the array.  */
2923       r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2924       break;
2925
2926     default:
2927       r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2928       break;
2929     }
2930
2931   switch (version)
2932     {
2933     case E_NDS32_ELF_VER_1_2:
2934     case E_NDS32_ELF_VER_1_3:
2935     case E_NDS32_ELF_VER_1_4:
2936       r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2937       break;
2938
2939     default:
2940       r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2941       break;
2942     }
2943
2944   if (E_NDS_ABI_V0 == abi)
2945     {
2946       /* OLD ABI; only used in N1213HC, has performance extension 1.  */
2947       r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2948       if (arch == E_NDS_ARCH_STAR_V1_0)
2949         r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2950       return;
2951     }
2952
2953   switch (arch)
2954     {
2955     case E_NDS_ARCH_STAR_V1_0:
2956     case E_NDS_ARCH_STAR_V2_0:
2957     case E_NDS_ARCH_STAR_V3_0:
2958     case E_NDS_ARCH_STAR_V3_M:
2959       r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2960       break;
2961
2962     default:
2963       r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2964       /* ARCH version determines how the e_flags are interpreted.
2965          If it is unknown, we cannot proceed.  */
2966       return;
2967     }
2968
2969   /* Newer ABI; Now handle architecture specific flags.  */
2970   if (arch == E_NDS_ARCH_STAR_V1_0)
2971     {
2972       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2973         r += snprintf (buf + r, size -r, ", MFUSR_PC");
2974
2975       if (!(config & E_NDS32_HAS_NO_MAC_INST))
2976         r += snprintf (buf + r, size -r, ", MAC");
2977
2978       if (config & E_NDS32_HAS_DIV_INST)
2979         r += snprintf (buf + r, size -r, ", DIV");
2980
2981       if (config & E_NDS32_HAS_16BIT_INST)
2982         r += snprintf (buf + r, size -r, ", 16b");
2983     }
2984   else
2985     {
2986       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2987         {
2988           if (version <= E_NDS32_ELF_VER_1_3)
2989             r += snprintf (buf + r, size -r, ", [B8]");
2990           else
2991             r += snprintf (buf + r, size -r, ", EX9");
2992         }
2993
2994       if (config & E_NDS32_HAS_MAC_DX_INST)
2995         r += snprintf (buf + r, size -r, ", MAC_DX");
2996
2997       if (config & E_NDS32_HAS_DIV_DX_INST)
2998         r += snprintf (buf + r, size -r, ", DIV_DX");
2999
3000       if (config & E_NDS32_HAS_16BIT_INST)
3001         {
3002           if (version <= E_NDS32_ELF_VER_1_3)
3003             r += snprintf (buf + r, size -r, ", 16b");
3004           else
3005             r += snprintf (buf + r, size -r, ", IFC");
3006         }
3007     }
3008
3009   if (config & E_NDS32_HAS_EXT_INST)
3010     r += snprintf (buf + r, size -r, ", PERF1");
3011
3012   if (config & E_NDS32_HAS_EXT2_INST)
3013     r += snprintf (buf + r, size -r, ", PERF2");
3014
3015   if (config & E_NDS32_HAS_FPU_INST)
3016     {
3017       has_fpu = TRUE;
3018       r += snprintf (buf + r, size -r, ", FPU_SP");
3019     }
3020
3021   if (config & E_NDS32_HAS_FPU_DP_INST)
3022     {
3023       has_fpu = TRUE;
3024       r += snprintf (buf + r, size -r, ", FPU_DP");
3025     }
3026
3027   if (config & E_NDS32_HAS_FPU_MAC_INST)
3028     {
3029       has_fpu = TRUE;
3030       r += snprintf (buf + r, size -r, ", FPU_MAC");
3031     }
3032
3033   if (has_fpu)
3034     {
3035       switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
3036         {
3037         case E_NDS32_FPU_REG_8SP_4DP:
3038           r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
3039           break;
3040         case E_NDS32_FPU_REG_16SP_8DP:
3041           r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
3042           break;
3043         case E_NDS32_FPU_REG_32SP_16DP:
3044           r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
3045           break;
3046         case E_NDS32_FPU_REG_32SP_32DP:
3047           r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
3048           break;
3049         }
3050     }
3051
3052   if (config & E_NDS32_HAS_AUDIO_INST)
3053     r += snprintf (buf + r, size -r, ", AUDIO");
3054
3055   if (config & E_NDS32_HAS_STRING_INST)
3056     r += snprintf (buf + r, size -r, ", STR");
3057
3058   if (config & E_NDS32_HAS_REDUCED_REGS)
3059     r += snprintf (buf + r, size -r, ", 16REG");
3060
3061   if (config & E_NDS32_HAS_VIDEO_INST)
3062     {
3063       if (version <= E_NDS32_ELF_VER_1_3)
3064         r += snprintf (buf + r, size -r, ", VIDEO");
3065       else
3066         r += snprintf (buf + r, size -r, ", SATURATION");
3067     }
3068
3069   if (config & E_NDS32_HAS_ENCRIPT_INST)
3070     r += snprintf (buf + r, size -r, ", ENCRP");
3071
3072   if (config & E_NDS32_HAS_L2C_INST)
3073     r += snprintf (buf + r, size -r, ", L2C");
3074 }
3075
3076 static char *
3077 get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine)
3078 {
3079   static char buf[1024];
3080
3081   buf[0] = '\0';
3082
3083   if (e_flags)
3084     {
3085       switch (e_machine)
3086         {
3087         default:
3088           break;
3089
3090         case EM_ARC_COMPACT2:
3091         case EM_ARC_COMPACT:
3092           decode_ARC_machine_flags (e_flags, e_machine, buf);
3093           break;
3094
3095         case EM_ARM:
3096           decode_ARM_machine_flags (e_flags, buf);
3097           break;
3098
3099         case EM_AVR:
3100           decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3101           break;
3102
3103         case EM_BLACKFIN:
3104           if (e_flags & EF_BFIN_PIC)
3105             strcat (buf, ", PIC");
3106
3107           if (e_flags & EF_BFIN_FDPIC)
3108             strcat (buf, ", FDPIC");
3109
3110           if (e_flags & EF_BFIN_CODE_IN_L1)
3111             strcat (buf, ", code in L1");
3112
3113           if (e_flags & EF_BFIN_DATA_IN_L1)
3114             strcat (buf, ", data in L1");
3115
3116           break;
3117
3118         case EM_CYGNUS_FRV:
3119           switch (e_flags & EF_FRV_CPU_MASK)
3120             {
3121             case EF_FRV_CPU_GENERIC:
3122               break;
3123
3124             default:
3125               strcat (buf, ", fr???");
3126               break;
3127
3128             case EF_FRV_CPU_FR300:
3129               strcat (buf, ", fr300");
3130               break;
3131
3132             case EF_FRV_CPU_FR400:
3133               strcat (buf, ", fr400");
3134               break;
3135             case EF_FRV_CPU_FR405:
3136               strcat (buf, ", fr405");
3137               break;
3138
3139             case EF_FRV_CPU_FR450:
3140               strcat (buf, ", fr450");
3141               break;
3142
3143             case EF_FRV_CPU_FR500:
3144               strcat (buf, ", fr500");
3145               break;
3146             case EF_FRV_CPU_FR550:
3147               strcat (buf, ", fr550");
3148               break;
3149
3150             case EF_FRV_CPU_SIMPLE:
3151               strcat (buf, ", simple");
3152               break;
3153             case EF_FRV_CPU_TOMCAT:
3154               strcat (buf, ", tomcat");
3155               break;
3156             }
3157           break;
3158
3159         case EM_68K:
3160           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3161             strcat (buf, ", m68000");
3162           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3163             strcat (buf, ", cpu32");
3164           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3165             strcat (buf, ", fido_a");
3166           else
3167             {
3168               char const * isa = _("unknown");
3169               char const * mac = _("unknown mac");
3170               char const * additional = NULL;
3171
3172               switch (e_flags & EF_M68K_CF_ISA_MASK)
3173                 {
3174                 case EF_M68K_CF_ISA_A_NODIV:
3175                   isa = "A";
3176                   additional = ", nodiv";
3177                   break;
3178                 case EF_M68K_CF_ISA_A:
3179                   isa = "A";
3180                   break;
3181                 case EF_M68K_CF_ISA_A_PLUS:
3182                   isa = "A+";
3183                   break;
3184                 case EF_M68K_CF_ISA_B_NOUSP:
3185                   isa = "B";
3186                   additional = ", nousp";
3187                   break;
3188                 case EF_M68K_CF_ISA_B:
3189                   isa = "B";
3190                   break;
3191                 case EF_M68K_CF_ISA_C:
3192                   isa = "C";
3193                   break;
3194                 case EF_M68K_CF_ISA_C_NODIV:
3195                   isa = "C";
3196                   additional = ", nodiv";
3197                   break;
3198                 }
3199               strcat (buf, ", cf, isa ");
3200               strcat (buf, isa);
3201               if (additional)
3202                 strcat (buf, additional);
3203               if (e_flags & EF_M68K_CF_FLOAT)
3204                 strcat (buf, ", float");
3205               switch (e_flags & EF_M68K_CF_MAC_MASK)
3206                 {
3207                 case 0:
3208                   mac = NULL;
3209                   break;
3210                 case EF_M68K_CF_MAC:
3211                   mac = "mac";
3212                   break;
3213                 case EF_M68K_CF_EMAC:
3214                   mac = "emac";
3215                   break;
3216                 case EF_M68K_CF_EMAC_B:
3217                   mac = "emac_b";
3218                   break;
3219                 }
3220               if (mac)
3221                 {
3222                   strcat (buf, ", ");
3223                   strcat (buf, mac);
3224                 }
3225             }
3226           break;
3227
3228         case EM_CYGNUS_MEP:
3229           switch (e_flags & EF_MEP_CPU_MASK)
3230             {
3231             case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3232             case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3233             case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3234             case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3235             case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3236             case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3237             default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3238             }
3239
3240           switch (e_flags & EF_MEP_COP_MASK)
3241             {
3242             case EF_MEP_COP_NONE: break;
3243             case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3244             case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3245             case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3246             case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3247             default: strcat (buf, _("<unknown MeP copro type>")); break;
3248             }
3249
3250           if (e_flags & EF_MEP_LIBRARY)
3251             strcat (buf, ", Built for Library");
3252
3253           if (e_flags & EF_MEP_INDEX_MASK)
3254             sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3255                      e_flags & EF_MEP_INDEX_MASK);
3256
3257           if (e_flags & ~ EF_MEP_ALL_FLAGS)
3258             sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3259                      e_flags & ~ EF_MEP_ALL_FLAGS);
3260           break;
3261
3262         case EM_PPC:
3263           if (e_flags & EF_PPC_EMB)
3264             strcat (buf, ", emb");
3265
3266           if (e_flags & EF_PPC_RELOCATABLE)
3267             strcat (buf, _(", relocatable"));
3268
3269           if (e_flags & EF_PPC_RELOCATABLE_LIB)
3270             strcat (buf, _(", relocatable-lib"));
3271           break;
3272
3273         case EM_PPC64:
3274           if (e_flags & EF_PPC64_ABI)
3275             {
3276               char abi[] = ", abiv0";
3277
3278               abi[6] += e_flags & EF_PPC64_ABI;
3279               strcat (buf, abi);
3280             }
3281           break;
3282
3283         case EM_V800:
3284           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3285             strcat (buf, ", RH850 ABI");
3286
3287           if (e_flags & EF_V800_850E3)
3288             strcat (buf, ", V3 architecture");
3289
3290           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3291             strcat (buf, ", FPU not used");
3292
3293           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3294             strcat (buf, ", regmode: COMMON");
3295
3296           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3297             strcat (buf, ", r4 not used");
3298
3299           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3300             strcat (buf, ", r30 not used");
3301
3302           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3303             strcat (buf, ", r5 not used");
3304
3305           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3306             strcat (buf, ", r2 not used");
3307
3308           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3309             {
3310               switch (e_flags & - e_flags)
3311                 {
3312                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3313                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3314                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3315                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3316                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3317                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3318                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3319                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3320                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3321                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3322                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3323                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3324                 default: break;
3325                 }
3326             }
3327           break;
3328
3329         case EM_V850:
3330         case EM_CYGNUS_V850:
3331           switch (e_flags & EF_V850_ARCH)
3332             {
3333             case E_V850E3V5_ARCH:
3334               strcat (buf, ", v850e3v5");
3335               break;
3336             case E_V850E2V3_ARCH:
3337               strcat (buf, ", v850e2v3");
3338               break;
3339             case E_V850E2_ARCH:
3340               strcat (buf, ", v850e2");
3341               break;
3342             case E_V850E1_ARCH:
3343               strcat (buf, ", v850e1");
3344               break;
3345             case E_V850E_ARCH:
3346               strcat (buf, ", v850e");
3347               break;
3348             case E_V850_ARCH:
3349               strcat (buf, ", v850");
3350               break;
3351             default:
3352               strcat (buf, _(", unknown v850 architecture variant"));
3353               break;
3354             }
3355           break;
3356
3357         case EM_M32R:
3358         case EM_CYGNUS_M32R:
3359           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3360             strcat (buf, ", m32r");
3361           break;
3362
3363         case EM_MIPS:
3364         case EM_MIPS_RS3_LE:
3365           if (e_flags & EF_MIPS_NOREORDER)
3366             strcat (buf, ", noreorder");
3367
3368           if (e_flags & EF_MIPS_PIC)
3369             strcat (buf, ", pic");
3370
3371           if (e_flags & EF_MIPS_CPIC)
3372             strcat (buf, ", cpic");
3373
3374           if (e_flags & EF_MIPS_UCODE)
3375             strcat (buf, ", ugen_reserved");
3376
3377           if (e_flags & EF_MIPS_ABI2)
3378             strcat (buf, ", abi2");
3379
3380           if (e_flags & EF_MIPS_OPTIONS_FIRST)
3381             strcat (buf, ", odk first");
3382
3383           if (e_flags & EF_MIPS_32BITMODE)
3384             strcat (buf, ", 32bitmode");
3385
3386           if (e_flags & EF_MIPS_NAN2008)
3387             strcat (buf, ", nan2008");
3388
3389           if (e_flags & EF_MIPS_FP64)
3390             strcat (buf, ", fp64");
3391
3392           switch ((e_flags & EF_MIPS_MACH))
3393             {
3394             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3395             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3396             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3397             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3398             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3399             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3400             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3401             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3402             case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break;
3403             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
3404             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3405             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3406             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3407             case E_MIPS_MACH_GS464: strcat (buf, ", gs464"); break;
3408             case E_MIPS_MACH_GS464E: strcat (buf, ", gs464e"); break;
3409             case E_MIPS_MACH_GS264E: strcat (buf, ", gs264e"); break;
3410             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3411             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3412             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3413             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
3414             case E_MIPS_MACH_IAMR2:  strcat (buf, ", interaptiv-mr2"); break;
3415             case 0:
3416             /* We simply ignore the field in this case to avoid confusion:
3417                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3418                extension.  */
3419               break;
3420             default: strcat (buf, _(", unknown CPU")); break;
3421             }
3422
3423           switch ((e_flags & EF_MIPS_ABI))
3424             {
3425             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3426             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3427             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3428             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3429             case 0:
3430             /* We simply ignore the field in this case to avoid confusion:
3431                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3432                This means it is likely to be an o32 file, but not for
3433                sure.  */
3434               break;
3435             default: strcat (buf, _(", unknown ABI")); break;
3436             }
3437
3438           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3439             strcat (buf, ", mdmx");
3440
3441           if (e_flags & EF_MIPS_ARCH_ASE_M16)
3442             strcat (buf, ", mips16");
3443
3444           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3445             strcat (buf, ", micromips");
3446
3447           switch ((e_flags & EF_MIPS_ARCH))
3448             {
3449             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3450             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3451             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3452             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3453             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3454             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3455             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3456             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3457             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3458             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3459             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3460             default: strcat (buf, _(", unknown ISA")); break;
3461             }
3462           break;
3463
3464         case EM_NDS32:
3465           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3466           break;
3467
3468         case EM_NFP:
3469           switch (EF_NFP_MACH (e_flags))
3470             {
3471             case E_NFP_MACH_3200:
3472               strcat (buf, ", NFP-32xx");
3473               break;
3474             case E_NFP_MACH_6000:
3475               strcat (buf, ", NFP-6xxx");
3476               break;
3477             }
3478           break;
3479
3480         case EM_RISCV:
3481           if (e_flags & EF_RISCV_RVC)
3482             strcat (buf, ", RVC");
3483
3484           if (e_flags & EF_RISCV_RVE)
3485             strcat (buf, ", RVE");
3486
3487           switch (e_flags & EF_RISCV_FLOAT_ABI)
3488             {
3489             case EF_RISCV_FLOAT_ABI_SOFT:
3490               strcat (buf, ", soft-float ABI");
3491               break;
3492
3493             case EF_RISCV_FLOAT_ABI_SINGLE:
3494               strcat (buf, ", single-float ABI");
3495               break;
3496
3497             case EF_RISCV_FLOAT_ABI_DOUBLE:
3498               strcat (buf, ", double-float ABI");
3499               break;
3500
3501             case EF_RISCV_FLOAT_ABI_QUAD:
3502               strcat (buf, ", quad-float ABI");
3503               break;
3504             }
3505           break;
3506
3507         case EM_SH:
3508           switch ((e_flags & EF_SH_MACH_MASK))
3509             {
3510             case EF_SH1: strcat (buf, ", sh1"); break;
3511             case EF_SH2: strcat (buf, ", sh2"); break;
3512             case EF_SH3: strcat (buf, ", sh3"); break;
3513             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3514             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3515             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3516             case EF_SH3E: strcat (buf, ", sh3e"); break;
3517             case EF_SH4: strcat (buf, ", sh4"); break;
3518             case EF_SH5: strcat (buf, ", sh5"); break;
3519             case EF_SH2E: strcat (buf, ", sh2e"); break;
3520             case EF_SH4A: strcat (buf, ", sh4a"); break;
3521             case EF_SH2A: strcat (buf, ", sh2a"); break;
3522             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3523             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3524             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3525             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3526             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3527             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3528             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3529             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3530             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3531             default: strcat (buf, _(", unknown ISA")); break;
3532             }
3533
3534           if (e_flags & EF_SH_PIC)
3535             strcat (buf, ", pic");
3536
3537           if (e_flags & EF_SH_FDPIC)
3538             strcat (buf, ", fdpic");
3539           break;
3540
3541         case EM_OR1K:
3542           if (e_flags & EF_OR1K_NODELAY)
3543             strcat (buf, ", no delay");
3544           break;
3545
3546         case EM_SPARCV9:
3547           if (e_flags & EF_SPARC_32PLUS)
3548             strcat (buf, ", v8+");
3549
3550           if (e_flags & EF_SPARC_SUN_US1)
3551             strcat (buf, ", ultrasparcI");
3552
3553           if (e_flags & EF_SPARC_SUN_US3)
3554             strcat (buf, ", ultrasparcIII");
3555
3556           if (e_flags & EF_SPARC_HAL_R1)
3557             strcat (buf, ", halr1");
3558
3559           if (e_flags & EF_SPARC_LEDATA)
3560             strcat (buf, ", ledata");
3561
3562           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3563             strcat (buf, ", tso");
3564
3565           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3566             strcat (buf, ", pso");
3567
3568           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3569             strcat (buf, ", rmo");
3570           break;
3571
3572         case EM_PARISC:
3573           switch (e_flags & EF_PARISC_ARCH)
3574             {
3575             case EFA_PARISC_1_0:
3576               strcpy (buf, ", PA-RISC 1.0");
3577               break;
3578             case EFA_PARISC_1_1:
3579               strcpy (buf, ", PA-RISC 1.1");
3580               break;
3581             case EFA_PARISC_2_0:
3582               strcpy (buf, ", PA-RISC 2.0");
3583               break;
3584             default:
3585               break;
3586             }
3587           if (e_flags & EF_PARISC_TRAPNIL)
3588             strcat (buf, ", trapnil");
3589           if (e_flags & EF_PARISC_EXT)
3590             strcat (buf, ", ext");
3591           if (e_flags & EF_PARISC_LSB)
3592             strcat (buf, ", lsb");
3593           if (e_flags & EF_PARISC_WIDE)
3594             strcat (buf, ", wide");
3595           if (e_flags & EF_PARISC_NO_KABP)
3596             strcat (buf, ", no kabp");
3597           if (e_flags & EF_PARISC_LAZYSWAP)
3598             strcat (buf, ", lazyswap");
3599           break;
3600
3601         case EM_PJ:
3602         case EM_PJ_OLD:
3603           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3604             strcat (buf, ", new calling convention");
3605
3606           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3607             strcat (buf, ", gnu calling convention");
3608           break;
3609
3610         case EM_IA_64:
3611           if ((e_flags & EF_IA_64_ABI64))
3612             strcat (buf, ", 64-bit");
3613           else
3614             strcat (buf, ", 32-bit");
3615           if ((e_flags & EF_IA_64_REDUCEDFP))
3616             strcat (buf, ", reduced fp model");
3617           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3618             strcat (buf, ", no function descriptors, constant gp");
3619           else if ((e_flags & EF_IA_64_CONS_GP))
3620             strcat (buf, ", constant gp");
3621           if ((e_flags & EF_IA_64_ABSOLUTE))
3622             strcat (buf, ", absolute");
3623           if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3624             {
3625               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3626                 strcat (buf, ", vms_linkages");
3627               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3628                 {
3629                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3630                   break;
3631                 case EF_IA_64_VMS_COMCOD_WARNING:
3632                   strcat (buf, ", warning");
3633                   break;
3634                 case EF_IA_64_VMS_COMCOD_ERROR:
3635                   strcat (buf, ", error");
3636                   break;
3637                 case EF_IA_64_VMS_COMCOD_ABORT:
3638                   strcat (buf, ", abort");
3639                   break;
3640                 default:
3641                   warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3642                         e_flags & EF_IA_64_VMS_COMCOD);
3643                   strcat (buf, ", <unknown>");
3644                 }
3645             }
3646           break;
3647
3648         case EM_VAX:
3649           if ((e_flags & EF_VAX_NONPIC))
3650             strcat (buf, ", non-PIC");
3651           if ((e_flags & EF_VAX_DFLOAT))
3652             strcat (buf, ", D-Float");
3653           if ((e_flags & EF_VAX_GFLOAT))
3654             strcat (buf, ", G-Float");
3655           break;
3656
3657         case EM_VISIUM:
3658           if (e_flags & EF_VISIUM_ARCH_MCM)
3659             strcat (buf, ", mcm");
3660           else if (e_flags & EF_VISIUM_ARCH_MCM24)
3661             strcat (buf, ", mcm24");
3662           if (e_flags & EF_VISIUM_ARCH_GR6)
3663             strcat (buf, ", gr6");
3664           break;
3665
3666         case EM_RL78:
3667           switch (e_flags & E_FLAG_RL78_CPU_MASK)
3668             {
3669             case E_FLAG_RL78_ANY_CPU: break;
3670             case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3671             case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3672             case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3673             }
3674           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3675             strcat (buf, ", 64-bit doubles");
3676           break;
3677
3678         case EM_RX:
3679           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3680             strcat (buf, ", 64-bit doubles");
3681           if (e_flags & E_FLAG_RX_DSP)
3682             strcat (buf, ", dsp");
3683           if (e_flags & E_FLAG_RX_PID)
3684             strcat (buf, ", pid");
3685           if (e_flags & E_FLAG_RX_ABI)
3686             strcat (buf, ", RX ABI");
3687           if (e_flags & E_FLAG_RX_SINSNS_SET)
3688             strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3689                     ? ", uses String instructions" : ", bans String instructions");
3690           if (e_flags & E_FLAG_RX_V2)
3691             strcat (buf, ", V2");
3692           break;
3693
3694         case EM_S390:
3695           if (e_flags & EF_S390_HIGH_GPRS)
3696             strcat (buf, ", highgprs");
3697           break;
3698
3699         case EM_TI_C6000:
3700           if ((e_flags & EF_C6000_REL))
3701             strcat (buf, ", relocatable module");
3702           break;
3703
3704         case EM_MSP430:
3705           strcat (buf, _(": architecture variant: "));
3706           switch (e_flags & EF_MSP430_MACH)
3707             {
3708             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3709             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3710             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3711             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3712             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3713             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3714             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3715             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3716             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3717             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3718             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3719             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3720             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3721             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3722             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3723             default:
3724               strcat (buf, _(": unknown")); break;
3725             }
3726
3727           if (e_flags & ~ EF_MSP430_MACH)
3728             strcat (buf, _(": unknown extra flag bits also present"));
3729         }
3730     }
3731
3732   return buf;
3733 }
3734
3735 static const char *
3736 get_osabi_name (Filedata * filedata, unsigned int osabi)
3737 {
3738   static char buff[32];
3739
3740   switch (osabi)
3741     {
3742     case ELFOSABI_NONE:         return "UNIX - System V";
3743     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3744     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3745     case ELFOSABI_GNU:          return "UNIX - GNU";
3746     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3747     case ELFOSABI_AIX:          return "UNIX - AIX";
3748     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3749     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3750     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3751     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3752     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3753     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3754     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3755     case ELFOSABI_AROS:         return "AROS";
3756     case ELFOSABI_FENIXOS:      return "FenixOS";
3757     case ELFOSABI_CLOUDABI:     return "Nuxi CloudABI";
3758     case ELFOSABI_OPENVOS:      return "Stratus Technologies OpenVOS";
3759     default:
3760       if (osabi >= 64)
3761         switch (filedata->file_header.e_machine)
3762           {
3763           case EM_ARM:
3764             switch (osabi)
3765               {
3766               case ELFOSABI_ARM:        return "ARM";
3767               case ELFOSABI_ARM_FDPIC:  return "ARM FDPIC";
3768               default:
3769                 break;
3770               }
3771             break;
3772
3773           case EM_MSP430:
3774           case EM_MSP430_OLD:
3775           case EM_VISIUM:
3776             switch (osabi)
3777               {
3778               case ELFOSABI_STANDALONE: return _("Standalone App");
3779               default:
3780                 break;
3781               }
3782             break;
3783
3784           case EM_TI_C6000:
3785             switch (osabi)
3786               {
3787               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3788               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3789               default:
3790                 break;
3791               }
3792             break;
3793
3794           default:
3795             break;
3796           }
3797       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3798       return buff;
3799     }
3800 }
3801
3802 static const char *
3803 get_aarch64_segment_type (unsigned long type)
3804 {
3805   switch (type)
3806     {
3807     case PT_AARCH64_ARCHEXT:  return "AARCH64_ARCHEXT";
3808     default:                  return NULL;
3809     }
3810 }
3811
3812 static const char *
3813 get_arm_segment_type (unsigned long type)
3814 {
3815   switch (type)
3816     {
3817     case PT_ARM_EXIDX: return "EXIDX";
3818     default:           return NULL;
3819     }
3820 }
3821
3822 static const char *
3823 get_s390_segment_type (unsigned long type)
3824 {
3825   switch (type)
3826     {
3827     case PT_S390_PGSTE: return "S390_PGSTE";
3828     default:            return NULL;
3829     }
3830 }
3831
3832 static const char *
3833 get_mips_segment_type (unsigned long type)
3834 {
3835   switch (type)
3836     {
3837     case PT_MIPS_REGINFO:   return "REGINFO";
3838     case PT_MIPS_RTPROC:    return "RTPROC";
3839     case PT_MIPS_OPTIONS:   return "OPTIONS";
3840     case PT_MIPS_ABIFLAGS:  return "ABIFLAGS";
3841     default:                return NULL;
3842     }
3843 }
3844
3845 static const char *
3846 get_parisc_segment_type (unsigned long type)
3847 {
3848   switch (type)
3849     {
3850     case PT_HP_TLS:             return "HP_TLS";
3851     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3852     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3853     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3854     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3855     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3856     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3857     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3858     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3859     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3860     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3861     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3862     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3863     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3864     case PT_HP_STACK:           return "HP_STACK";
3865     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3866     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3867     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3868     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3869     default:                    return NULL;
3870     }
3871 }
3872
3873 static const char *
3874 get_ia64_segment_type (unsigned long type)
3875 {
3876   switch (type)
3877     {
3878     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3879     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3880     case PT_HP_TLS:             return "HP_TLS";
3881     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3882     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3883     case PT_IA_64_HP_STACK:     return "HP_STACK";
3884     default:                    return NULL;
3885     }
3886 }
3887
3888 static const char *
3889 get_tic6x_segment_type (unsigned long type)
3890 {
3891   switch (type)
3892     {
3893     case PT_C6000_PHATTR:  return "C6000_PHATTR";
3894     default:               return NULL;
3895     }
3896 }
3897
3898 static const char *
3899 get_solaris_segment_type (unsigned long type)
3900 {
3901   switch (type)
3902     {
3903     case 0x6464e550: return "PT_SUNW_UNWIND";
3904     case 0x6474e550: return "PT_SUNW_EH_FRAME";
3905     case 0x6ffffff7: return "PT_LOSUNW";
3906     case 0x6ffffffa: return "PT_SUNWBSS";
3907     case 0x6ffffffb: return "PT_SUNWSTACK";
3908     case 0x6ffffffc: return "PT_SUNWDTRACE";
3909     case 0x6ffffffd: return "PT_SUNWCAP";
3910     case 0x6fffffff: return "PT_HISUNW";
3911     default:         return NULL;
3912     }
3913 }
3914
3915 static const char *
3916 get_segment_type (Filedata * filedata, unsigned long p_type)
3917 {
3918   static char buff[32];
3919
3920   switch (p_type)
3921     {
3922     case PT_NULL:       return "NULL";
3923     case PT_LOAD:       return "LOAD";
3924     case PT_DYNAMIC:    return "DYNAMIC";
3925     case PT_INTERP:     return "INTERP";
3926     case PT_NOTE:       return "NOTE";
3927     case PT_SHLIB:      return "SHLIB";
3928     case PT_PHDR:       return "PHDR";
3929     case PT_TLS:        return "TLS";
3930     case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3931     case PT_GNU_STACK:  return "GNU_STACK";
3932     case PT_GNU_RELRO:  return "GNU_RELRO";
3933
3934     default:
3935       if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
3936         {
3937           sprintf (buff, "GNU_MBIND+%#lx",
3938                    p_type - PT_GNU_MBIND_LO);
3939         }
3940       else if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3941         {
3942           const char * result;
3943
3944           switch (filedata->file_header.e_machine)
3945             {
3946             case EM_AARCH64:
3947               result = get_aarch64_segment_type (p_type);
3948               break;
3949             case EM_ARM:
3950               result = get_arm_segment_type (p_type);
3951               break;
3952             case EM_MIPS:
3953             case EM_MIPS_RS3_LE:
3954               result = get_mips_segment_type (p_type);
3955               break;
3956             case EM_PARISC:
3957               result = get_parisc_segment_type (p_type);
3958               break;
3959             case EM_IA_64:
3960               result = get_ia64_segment_type (p_type);
3961               break;
3962             case EM_TI_C6000:
3963               result = get_tic6x_segment_type (p_type);
3964               break;
3965             case EM_S390:
3966             case EM_S390_OLD:
3967               result = get_s390_segment_type (p_type);
3968               break;
3969             default:
3970               result = NULL;
3971               break;
3972             }
3973
3974           if (result != NULL)
3975             return result;
3976
3977           sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
3978         }
3979       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3980         {
3981           const char * result;
3982
3983           switch (filedata->file_header.e_machine)
3984             {
3985             case EM_PARISC:
3986               result = get_parisc_segment_type (p_type);
3987               break;
3988             case EM_IA_64:
3989               result = get_ia64_segment_type (p_type);
3990               break;
3991             default:
3992               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3993                 result = get_solaris_segment_type (p_type);
3994               else
3995                 result = NULL;
3996               break;
3997             }
3998
3999           if (result != NULL)
4000             return result;
4001
4002           sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
4003         }
4004       else
4005         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
4006
4007       return buff;
4008     }
4009 }
4010
4011 static const char *
4012 get_arc_section_type_name (unsigned int sh_type)
4013 {
4014   switch (sh_type)
4015     {
4016     case SHT_ARC_ATTRIBUTES:      return "ARC_ATTRIBUTES";
4017     default:
4018       break;
4019     }
4020   return NULL;
4021 }
4022
4023 static const char *
4024 get_mips_section_type_name (unsigned int sh_type)
4025 {
4026   switch (sh_type)
4027     {
4028     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
4029     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
4030     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
4031     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
4032     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
4033     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
4034     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
4035     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
4036     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
4037     case SHT_MIPS_RELD:          return "MIPS_RELD";
4038     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
4039     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
4040     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
4041     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
4042     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
4043     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
4044     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
4045     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
4046     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
4047     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
4048     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
4049     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
4050     case SHT_MIPS_LINE:          return "MIPS_LINE";
4051     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
4052     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
4053     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
4054     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
4055     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
4056     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
4057     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
4058     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
4059     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
4060     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
4061     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
4062     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
4063     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
4064     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
4065     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
4066     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
4067     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
4068     default:
4069       break;
4070     }
4071   return NULL;
4072 }
4073
4074 static const char *
4075 get_parisc_section_type_name (unsigned int sh_type)
4076 {
4077   switch (sh_type)
4078     {
4079     case SHT_PARISC_EXT:        return "PARISC_EXT";
4080     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
4081     case SHT_PARISC_DOC:        return "PARISC_DOC";
4082     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
4083     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
4084     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
4085     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
4086     default:                    return NULL;
4087     }
4088 }
4089
4090 static const char *
4091 get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
4092 {
4093   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
4094   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4095     return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
4096
4097   switch (sh_type)
4098     {
4099     case SHT_IA_64_EXT:                return "IA_64_EXT";
4100     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
4101     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
4102     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
4103     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4104     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
4105     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
4106     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
4107     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
4108     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
4109     default:
4110       break;
4111     }
4112   return NULL;
4113 }
4114
4115 static const char *
4116 get_x86_64_section_type_name (unsigned int sh_type)
4117 {
4118   switch (sh_type)
4119     {
4120     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
4121     default:                    return NULL;
4122     }
4123 }
4124
4125 static const char *
4126 get_aarch64_section_type_name (unsigned int sh_type)
4127 {
4128   switch (sh_type)
4129     {
4130     case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4131     default:                     return NULL;
4132     }
4133 }
4134
4135 static const char *
4136 get_arm_section_type_name (unsigned int sh_type)
4137 {
4138   switch (sh_type)
4139     {
4140     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
4141     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
4142     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
4143     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
4144     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
4145     default:                      return NULL;
4146     }
4147 }
4148
4149 static const char *
4150 get_tic6x_section_type_name (unsigned int sh_type)
4151 {
4152   switch (sh_type)
4153     {
4154     case SHT_C6000_UNWIND:      return "C6000_UNWIND";
4155     case SHT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
4156     case SHT_C6000_ATTRIBUTES:  return "C6000_ATTRIBUTES";
4157     case SHT_TI_ICODE:          return "TI_ICODE";
4158     case SHT_TI_XREF:           return "TI_XREF";
4159     case SHT_TI_HANDLER:        return "TI_HANDLER";
4160     case SHT_TI_INITINFO:       return "TI_INITINFO";
4161     case SHT_TI_PHATTRS:        return "TI_PHATTRS";
4162     default:                    return NULL;
4163     }
4164 }
4165
4166 static const char *
4167 get_msp430x_section_type_name (unsigned int sh_type)
4168 {
4169   switch (sh_type)
4170     {
4171     case SHT_MSP430_SEC_FLAGS:    return "MSP430_SEC_FLAGS";
4172     case SHT_MSP430_SYM_ALIASES:  return "MSP430_SYM_ALIASES";
4173     case SHT_MSP430_ATTRIBUTES:   return "MSP430_ATTRIBUTES";
4174     default:                      return NULL;
4175     }
4176 }
4177
4178 static const char *
4179 get_nfp_section_type_name (unsigned int sh_type)
4180 {
4181   switch (sh_type)
4182     {
4183     case SHT_NFP_MECONFIG:      return "NFP_MECONFIG";
4184     case SHT_NFP_INITREG:       return "NFP_INITREG";
4185     case SHT_NFP_UDEBUG:        return "NFP_UDEBUG";
4186     default:                    return NULL;
4187     }
4188 }
4189
4190 static const char *
4191 get_v850_section_type_name (unsigned int sh_type)
4192 {
4193   switch (sh_type)
4194     {
4195     case SHT_V850_SCOMMON:  return "V850 Small Common";
4196     case SHT_V850_TCOMMON:  return "V850 Tiny Common";
4197     case SHT_V850_ZCOMMON:  return "V850 Zero Common";
4198     case SHT_RENESAS_IOP:   return "RENESAS IOP";
4199     case SHT_RENESAS_INFO:  return "RENESAS INFO";
4200     default:                return NULL;
4201     }
4202 }
4203
4204 static const char *
4205 get_section_type_name (Filedata * filedata, unsigned int sh_type)
4206 {
4207   static char buff[32];
4208   const char * result;
4209
4210   switch (sh_type)
4211     {
4212     case SHT_NULL:              return "NULL";
4213     case SHT_PROGBITS:          return "PROGBITS";
4214     case SHT_SYMTAB:            return "SYMTAB";
4215     case SHT_STRTAB:            return "STRTAB";
4216     case SHT_RELA:              return "RELA";
4217     case SHT_HASH:              return "HASH";
4218     case SHT_DYNAMIC:           return "DYNAMIC";
4219     case SHT_NOTE:              return "NOTE";
4220     case SHT_NOBITS:            return "NOBITS";
4221     case SHT_REL:               return "REL";
4222     case SHT_SHLIB:             return "SHLIB";
4223     case SHT_DYNSYM:            return "DYNSYM";
4224     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
4225     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
4226     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
4227     case SHT_GNU_HASH:          return "GNU_HASH";
4228     case SHT_GROUP:             return "GROUP";
4229     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICES";
4230     case SHT_GNU_verdef:        return "VERDEF";
4231     case SHT_GNU_verneed:       return "VERNEED";
4232     case SHT_GNU_versym:        return "VERSYM";
4233     case 0x6ffffff0:            return "VERSYM";
4234     case 0x6ffffffc:            return "VERDEF";
4235     case 0x7ffffffd:            return "AUXILIARY";
4236     case 0x7fffffff:            return "FILTER";
4237     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
4238
4239     default:
4240       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4241         {
4242           switch (filedata->file_header.e_machine)
4243             {
4244             case EM_ARC:
4245             case EM_ARC_COMPACT:
4246             case EM_ARC_COMPACT2:
4247               result = get_arc_section_type_name (sh_type);
4248               break;
4249             case EM_MIPS:
4250             case EM_MIPS_RS3_LE:
4251               result = get_mips_section_type_name (sh_type);
4252               break;
4253             case EM_PARISC:
4254               result = get_parisc_section_type_name (sh_type);
4255               break;
4256             case EM_IA_64:
4257               result = get_ia64_section_type_name (filedata, sh_type);
4258               break;
4259             case EM_X86_64:
4260             case EM_L1OM:
4261             case EM_K1OM:
4262               result = get_x86_64_section_type_name (sh_type);
4263               break;
4264             case EM_AARCH64:
4265               result = get_aarch64_section_type_name (sh_type);
4266               break;
4267             case EM_ARM:
4268               result = get_arm_section_type_name (sh_type);
4269               break;
4270             case EM_TI_C6000:
4271               result = get_tic6x_section_type_name (sh_type);
4272               break;
4273             case EM_MSP430:
4274               result = get_msp430x_section_type_name (sh_type);
4275               break;
4276             case EM_NFP:
4277               result = get_nfp_section_type_name (sh_type);
4278               break;
4279             case EM_V800:
4280             case EM_V850:
4281             case EM_CYGNUS_V850:
4282               result = get_v850_section_type_name (sh_type);
4283               break;
4284             default:
4285               result = NULL;
4286               break;
4287             }
4288
4289           if (result != NULL)
4290             return result;
4291
4292           sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4293         }
4294       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4295         {
4296           switch (filedata->file_header.e_machine)
4297             {
4298             case EM_IA_64:
4299               result = get_ia64_section_type_name (filedata, sh_type);
4300               break;
4301             default:
4302               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4303                 result = get_solaris_section_type (sh_type);
4304               else
4305                 {
4306                   switch (sh_type)
4307                     {
4308                     case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4309                     case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4310                     case SHT_GNU_HASH: result = "GNU_HASH"; break;
4311                     case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4312                     default:
4313                       result = NULL;
4314                       break;
4315                     }
4316                 }
4317               break;
4318             }
4319
4320           if (result != NULL)
4321             return result;
4322
4323           sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4324         }
4325       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4326         {
4327           switch (filedata->file_header.e_machine)
4328             {
4329             case EM_V800:
4330             case EM_V850:
4331             case EM_CYGNUS_V850:
4332               result = get_v850_section_type_name (sh_type);
4333               break;
4334             default:
4335               result = NULL;
4336               break;
4337             }
4338
4339           if (result != NULL)
4340             return result;
4341
4342           sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4343         }
4344       else
4345         /* This message is probably going to be displayed in a 15
4346            character wide field, so put the hex value first.  */
4347         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4348
4349       return buff;
4350     }
4351 }
4352
4353 #define OPTION_DEBUG_DUMP       512
4354 #define OPTION_DYN_SYMS         513
4355 #define OPTION_DWARF_DEPTH      514
4356 #define OPTION_DWARF_START      515
4357 #define OPTION_DWARF_CHECK      516
4358
4359 static struct option options[] =
4360 {
4361   {"all",              no_argument, 0, 'a'},
4362   {"file-header",      no_argument, 0, 'h'},
4363   {"program-headers",  no_argument, 0, 'l'},
4364   {"headers",          no_argument, 0, 'e'},
4365   {"histogram",        no_argument, 0, 'I'},
4366   {"segments",         no_argument, 0, 'l'},
4367   {"sections",         no_argument, 0, 'S'},
4368   {"section-headers",  no_argument, 0, 'S'},
4369   {"section-groups",   no_argument, 0, 'g'},
4370   {"section-details",  no_argument, 0, 't'},
4371   {"full-section-name",no_argument, 0, 'N'},
4372   {"symbols",          no_argument, 0, 's'},
4373   {"syms",             no_argument, 0, 's'},
4374   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
4375   {"relocs",           no_argument, 0, 'r'},
4376   {"notes",            no_argument, 0, 'n'},
4377   {"dynamic",          no_argument, 0, 'd'},
4378   {"arch-specific",    no_argument, 0, 'A'},
4379   {"version-info",     no_argument, 0, 'V'},
4380   {"use-dynamic",      no_argument, 0, 'D'},
4381   {"unwind",           no_argument, 0, 'u'},
4382   {"archive-index",    no_argument, 0, 'c'},
4383   {"hex-dump",         required_argument, 0, 'x'},
4384   {"relocated-dump",   required_argument, 0, 'R'},
4385   {"string-dump",      required_argument, 0, 'p'},
4386   {"decompress",       no_argument, 0, 'z'},
4387 #ifdef SUPPORT_DISASSEMBLY
4388   {"instruction-dump", required_argument, 0, 'i'},
4389 #endif
4390   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
4391
4392   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
4393   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
4394   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
4395
4396   {"version",          no_argument, 0, 'v'},
4397   {"wide",             no_argument, 0, 'W'},
4398   {"help",             no_argument, 0, 'H'},
4399   {0,                  no_argument, 0, 0}
4400 };
4401
4402 static void
4403 usage (FILE * stream)
4404 {
4405   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4406   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4407   fprintf (stream, _(" Options are:\n\
4408   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4409   -h --file-header       Display the ELF file header\n\
4410   -l --program-headers   Display the program headers\n\
4411      --segments          An alias for --program-headers\n\
4412   -S --section-headers   Display the sections' header\n\
4413      --sections          An alias for --section-headers\n\
4414   -g --section-groups    Display the section groups\n\
4415   -t --section-details   Display the section details\n\
4416   -e --headers           Equivalent to: -h -l -S\n\
4417   -s --syms              Display the symbol table\n\
4418      --symbols           An alias for --syms\n\
4419   --dyn-syms             Display the dynamic symbol table\n\
4420   -n --notes             Display the core notes (if present)\n\
4421   -r --relocs            Display the relocations (if present)\n\
4422   -u --unwind            Display the unwind info (if present)\n\
4423   -d --dynamic           Display the dynamic section (if present)\n\
4424   -V --version-info      Display the version sections (if present)\n\
4425   -A --arch-specific     Display architecture specific information (if any)\n\
4426   -c --archive-index     Display the symbol/file index in an archive\n\
4427   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
4428   -x --hex-dump=<number|name>\n\
4429                          Dump the contents of section <number|name> as bytes\n\
4430   -p --string-dump=<number|name>\n\
4431                          Dump the contents of section <number|name> as strings\n\
4432   -R --relocated-dump=<number|name>\n\
4433                          Dump the contents of section <number|name> as relocated bytes\n\
4434   -z --decompress        Decompress section before dumping it\n\
4435   -w[lLiaprmfFsoRtUuTgAckK] or\n\
4436   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4437                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4438                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4439                =addr,=cu_index,=links,=follow-links]\n\
4440                          Display the contents of DWARF debug sections\n"));
4441   fprintf (stream, _("\
4442   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
4443   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
4444                          or deeper\n"));
4445 #ifdef SUPPORT_DISASSEMBLY
4446   fprintf (stream, _("\
4447   -i --instruction-dump=<number|name>\n\
4448                          Disassemble the contents of section <number|name>\n"));
4449 #endif
4450   fprintf (stream, _("\
4451   -I --histogram         Display histogram of bucket list lengths\n\
4452   -W --wide              Allow output width to exceed 80 characters\n\
4453   @<file>                Read options from <file>\n\
4454   -H --help              Display this information\n\
4455   -v --version           Display the version number of readelf\n"));
4456
4457   if (REPORT_BUGS_TO[0] && stream == stdout)
4458     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4459
4460   exit (stream == stdout ? 0 : 1);
4461 }
4462
4463 /* Record the fact that the user wants the contents of section number
4464    SECTION to be displayed using the method(s) encoded as flags bits
4465    in TYPE.  Note, TYPE can be zero if we are creating the array for
4466    the first time.  */
4467
4468 static void
4469 request_dump_bynumber (Filedata * filedata, unsigned int section, dump_type type)
4470 {
4471   if (section >= filedata->num_dump_sects)
4472     {
4473       dump_type * new_dump_sects;
4474
4475       new_dump_sects = (dump_type *) calloc (section + 1,
4476                                              sizeof (* new_dump_sects));
4477
4478       if (new_dump_sects == NULL)
4479         error (_("Out of memory allocating dump request table.\n"));
4480       else
4481         {
4482           if (filedata->dump_sects)
4483             {
4484               /* Copy current flag settings.  */
4485               memcpy (new_dump_sects, filedata->dump_sects,
4486                       filedata->num_dump_sects * sizeof (* new_dump_sects));
4487
4488               free (filedata->dump_sects);
4489             }
4490
4491           filedata->dump_sects = new_dump_sects;
4492           filedata->num_dump_sects = section + 1;
4493         }
4494     }
4495
4496   if (filedata->dump_sects)
4497     filedata->dump_sects[section] |= type;
4498 }
4499
4500 /* Request a dump by section name.  */
4501
4502 static void
4503 request_dump_byname (const char * section, dump_type type)
4504 {
4505   struct dump_list_entry * new_request;
4506
4507   new_request = (struct dump_list_entry *)
4508       malloc (sizeof (struct dump_list_entry));
4509   if (!new_request)
4510     error (_("Out of memory allocating dump request table.\n"));
4511
4512   new_request->name = strdup (section);
4513   if (!new_request->name)
4514     error (_("Out of memory allocating dump request table.\n"));
4515
4516   new_request->type = type;
4517
4518   new_request->next = dump_sects_byname;
4519   dump_sects_byname = new_request;
4520 }
4521
4522 static inline void
4523 request_dump (Filedata * filedata, dump_type type)
4524 {
4525   int section;
4526   char * cp;
4527
4528   do_dump++;
4529   section = strtoul (optarg, & cp, 0);
4530
4531   if (! *cp && section >= 0)
4532     request_dump_bynumber (filedata, section, type);
4533   else
4534     request_dump_byname (optarg, type);
4535 }
4536
4537 static void
4538 parse_args (Filedata * filedata, int argc, char ** argv)
4539 {
4540   int c;
4541
4542   if (argc < 2)
4543     usage (stderr);
4544
4545   while ((c = getopt_long
4546           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4547     {
4548       switch (c)
4549         {
4550         case 0:
4551           /* Long options.  */
4552           break;
4553         case 'H':
4554           usage (stdout);
4555           break;
4556
4557         case 'a':
4558           do_syms = TRUE;
4559           do_reloc = TRUE;
4560           do_unwind = TRUE;
4561           do_dynamic = TRUE;
4562           do_header = TRUE;
4563           do_sections = TRUE;
4564           do_section_groups = TRUE;
4565           do_segments = TRUE;
4566           do_version = TRUE;
4567           do_histogram = TRUE;
4568           do_arch = TRUE;
4569           do_notes = TRUE;
4570           break;
4571         case 'g':
4572           do_section_groups = TRUE;
4573           break;
4574         case 't':
4575         case 'N':
4576           do_sections = TRUE;
4577           do_section_details = TRUE;
4578           break;
4579         case 'e':
4580           do_header = TRUE;
4581           do_sections = TRUE;
4582           do_segments = TRUE;
4583           break;
4584         case 'A':
4585           do_arch = TRUE;
4586           break;
4587         case 'D':
4588           do_using_dynamic = TRUE;
4589           break;
4590         case 'r':
4591           do_reloc = TRUE;
4592           break;
4593         case 'u':
4594           do_unwind = TRUE;
4595           break;
4596         case 'h':
4597           do_header = TRUE;
4598           break;
4599         case 'l':
4600           do_segments = TRUE;
4601           break;
4602         case 's':
4603           do_syms = TRUE;
4604           break;
4605         case 'S':
4606           do_sections = TRUE;
4607           break;
4608         case 'd':
4609           do_dynamic = TRUE;
4610           break;
4611         case 'I':
4612           do_histogram = TRUE;
4613           break;
4614         case 'n':
4615           do_notes = TRUE;
4616           break;
4617         case 'c':
4618           do_archive_index = TRUE;
4619           break;
4620         case 'x':
4621           request_dump (filedata, HEX_DUMP);
4622           break;
4623         case 'p':
4624           request_dump (filedata, STRING_DUMP);
4625           break;
4626         case 'R':
4627           request_dump (filedata, RELOC_DUMP);
4628           break;
4629         case 'z':
4630           decompress_dumps = TRUE;
4631           break;
4632         case 'w':
4633           do_dump = TRUE;
4634           if (optarg == 0)
4635             {
4636               do_debugging = TRUE;
4637               dwarf_select_sections_all ();
4638             }
4639           else
4640             {
4641               do_debugging = FALSE;
4642               dwarf_select_sections_by_letters (optarg);
4643             }
4644           break;
4645         case OPTION_DEBUG_DUMP:
4646           do_dump = TRUE;
4647           if (optarg == 0)
4648             do_debugging = TRUE;
4649           else
4650             {
4651               do_debugging = FALSE;
4652               dwarf_select_sections_by_names (optarg);
4653             }
4654           break;
4655         case OPTION_DWARF_DEPTH:
4656           {
4657             char *cp;
4658
4659             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4660           }
4661           break;
4662         case OPTION_DWARF_START:
4663           {
4664             char *cp;
4665
4666             dwarf_start_die = strtoul (optarg, & cp, 0);
4667           }
4668           break;
4669         case OPTION_DWARF_CHECK:
4670           dwarf_check = TRUE;
4671           break;
4672         case OPTION_DYN_SYMS:
4673           do_dyn_syms = TRUE;
4674           break;
4675 #ifdef SUPPORT_DISASSEMBLY
4676         case 'i':
4677           request_dump (filedata, DISASS_DUMP);
4678           break;
4679 #endif
4680         case 'v':
4681           print_version (program_name);
4682           break;
4683         case 'V':
4684           do_version = TRUE;
4685           break;
4686         case 'W':
4687           do_wide = TRUE;
4688           break;
4689         default:
4690           /* xgettext:c-format */
4691           error (_("Invalid option '-%c'\n"), c);
4692           /* Fall through.  */
4693         case '?':
4694           usage (stderr);
4695         }
4696     }
4697
4698   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4699       && !do_segments && !do_header && !do_dump && !do_version
4700       && !do_histogram && !do_debugging && !do_arch && !do_notes
4701       && !do_section_groups && !do_archive_index
4702       && !do_dyn_syms)
4703     usage (stderr);
4704 }
4705
4706 static const char *
4707 get_elf_class (unsigned int elf_class)
4708 {
4709   static char buff[32];
4710
4711   switch (elf_class)
4712     {
4713     case ELFCLASSNONE: return _("none");
4714     case ELFCLASS32:   return "ELF32";
4715     case ELFCLASS64:   return "ELF64";
4716     default:
4717       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4718       return buff;
4719     }
4720 }
4721
4722 static const char *
4723 get_data_encoding (unsigned int encoding)
4724 {
4725   static char buff[32];
4726
4727   switch (encoding)
4728     {
4729     case ELFDATANONE: return _("none");
4730     case ELFDATA2LSB: return _("2's complement, little endian");
4731     case ELFDATA2MSB: return _("2's complement, big endian");
4732     default:
4733       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4734       return buff;
4735     }
4736 }
4737
4738 /* Decode the data held in 'filedata->file_header'.  */
4739
4740 static bfd_boolean
4741 process_file_header (Filedata * filedata)
4742 {
4743   Elf_Internal_Ehdr * header = & filedata->file_header;
4744
4745   if (   header->e_ident[EI_MAG0] != ELFMAG0
4746       || header->e_ident[EI_MAG1] != ELFMAG1
4747       || header->e_ident[EI_MAG2] != ELFMAG2
4748       || header->e_ident[EI_MAG3] != ELFMAG3)
4749     {
4750       error
4751         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4752       return FALSE;
4753     }
4754
4755   init_dwarf_regnames (header->e_machine);
4756
4757   if (do_header)
4758     {
4759       unsigned i;
4760
4761       printf (_("ELF Header:\n"));
4762       printf (_("  Magic:   "));
4763       for (i = 0; i < EI_NIDENT; i++)
4764         printf ("%2.2x ", header->e_ident[i]);
4765       printf ("\n");
4766       printf (_("  Class:                             %s\n"),
4767               get_elf_class (header->e_ident[EI_CLASS]));
4768       printf (_("  Data:                              %s\n"),
4769               get_data_encoding (header->e_ident[EI_DATA]));
4770       printf (_("  Version:                           %d%s\n"),
4771               header->e_ident[EI_VERSION],
4772               (header->e_ident[EI_VERSION] == EV_CURRENT
4773                ? _(" (current)")
4774                : (header->e_ident[EI_VERSION] != EV_NONE
4775                   ? _(" <unknown>")
4776                   : "")));
4777       printf (_("  OS/ABI:                            %s\n"),
4778               get_osabi_name (filedata, header->e_ident[EI_OSABI]));
4779       printf (_("  ABI Version:                       %d\n"),
4780               header->e_ident[EI_ABIVERSION]);
4781       printf (_("  Type:                              %s\n"),
4782               get_file_type (header->e_type));
4783       printf (_("  Machine:                           %s\n"),
4784               get_machine_name (header->e_machine));
4785       printf (_("  Version:                           0x%lx\n"),
4786               header->e_version);
4787
4788       printf (_("  Entry point address:               "));
4789       print_vma (header->e_entry, PREFIX_HEX);
4790       printf (_("\n  Start of program headers:          "));
4791       print_vma (header->e_phoff, DEC);
4792       printf (_(" (bytes into file)\n  Start of section headers:          "));
4793       print_vma (header->e_shoff, DEC);
4794       printf (_(" (bytes into file)\n"));
4795
4796       printf (_("  Flags:                             0x%lx%s\n"),
4797               header->e_flags,
4798               get_machine_flags (filedata, header->e_flags, header->e_machine));
4799       printf (_("  Size of this header:               %u (bytes)\n"),
4800               header->e_ehsize);
4801       printf (_("  Size of program headers:           %u (bytes)\n"),
4802               header->e_phentsize);
4803       printf (_("  Number of program headers:         %u"),
4804               header->e_phnum);
4805       if (filedata->section_headers != NULL
4806           && header->e_phnum == PN_XNUM
4807           && filedata->section_headers[0].sh_info != 0)
4808         {
4809           header->e_phnum = filedata->section_headers[0].sh_info;
4810           printf (" (%u)", header->e_phnum);
4811         }
4812       putc ('\n', stdout);
4813       printf (_("  Size of section headers:           %u (bytes)\n"),
4814               header->e_shentsize);
4815       printf (_("  Number of section headers:         %u"),
4816               header->e_shnum);
4817       if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
4818         {
4819           header->e_shnum = filedata->section_headers[0].sh_size;
4820           printf (" (%u)", header->e_shnum);
4821         }
4822       putc ('\n', stdout);
4823       printf (_("  Section header string table index: %u"),
4824               header->e_shstrndx);
4825       if (filedata->section_headers != NULL
4826           && header->e_shstrndx == (SHN_XINDEX & 0xffff))
4827         {
4828           header->e_shstrndx = filedata->section_headers[0].sh_link;
4829           printf (" (%u)", header->e_shstrndx);
4830         }
4831       if (header->e_shstrndx != SHN_UNDEF
4832           && header->e_shstrndx >= header->e_shnum)
4833         {
4834           header->e_shstrndx = SHN_UNDEF;
4835           printf (_(" <corrupt: out of range>"));
4836         }
4837       putc ('\n', stdout);
4838     }
4839
4840   if (filedata->section_headers != NULL)
4841     {
4842       if (header->e_phnum == PN_XNUM
4843           && filedata->section_headers[0].sh_info != 0)
4844         header->e_phnum = filedata->section_headers[0].sh_info;
4845       if (header->e_shnum == SHN_UNDEF)
4846         header->e_shnum = filedata->section_headers[0].sh_size;
4847       if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
4848         header->e_shstrndx = filedata->section_headers[0].sh_link;
4849       if (header->e_shstrndx >= header->e_shnum)
4850         header->e_shstrndx = SHN_UNDEF;
4851       free (filedata->section_headers);
4852       filedata->section_headers = NULL;
4853     }
4854
4855   return TRUE;
4856 }
4857
4858 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4859    Returns TRUE upon success, FALSE otherwise.  Loads 32-bit headers.  */
4860
4861 static bfd_boolean
4862 get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4863 {
4864   Elf32_External_Phdr * phdrs;
4865   Elf32_External_Phdr * external;
4866   Elf_Internal_Phdr *   internal;
4867   unsigned int i;
4868   unsigned int size = filedata->file_header.e_phentsize;
4869   unsigned int num  = filedata->file_header.e_phnum;
4870
4871   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4872   if (size == 0 || num == 0)
4873     return FALSE;
4874   if (size < sizeof * phdrs)
4875     {
4876       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4877       return FALSE;
4878     }
4879   if (size > sizeof * phdrs)
4880     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4881
4882   phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4883                                             size, num, _("program headers"));
4884   if (phdrs == NULL)
4885     return FALSE;
4886
4887   for (i = 0, internal = pheaders, external = phdrs;
4888        i < filedata->file_header.e_phnum;
4889        i++, internal++, external++)
4890     {
4891       internal->p_type   = BYTE_GET (external->p_type);
4892       internal->p_offset = BYTE_GET (external->p_offset);
4893       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4894       internal->p_paddr  = BYTE_GET (external->p_paddr);
4895       internal->p_filesz = BYTE_GET (external->p_filesz);
4896       internal->p_memsz  = BYTE_GET (external->p_memsz);
4897       internal->p_flags  = BYTE_GET (external->p_flags);
4898       internal->p_align  = BYTE_GET (external->p_align);
4899     }
4900
4901   free (phdrs);
4902   return TRUE;
4903 }
4904
4905 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4906    Returns TRUE upon success, FALSE otherwise.  Loads 64-bit headers.  */
4907
4908 static bfd_boolean
4909 get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4910 {
4911   Elf64_External_Phdr * phdrs;
4912   Elf64_External_Phdr * external;
4913   Elf_Internal_Phdr *   internal;
4914   unsigned int i;
4915   unsigned int size = filedata->file_header.e_phentsize;
4916   unsigned int num  = filedata->file_header.e_phnum;
4917
4918   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4919   if (size == 0 || num == 0)
4920     return FALSE;
4921   if (size < sizeof * phdrs)
4922     {
4923       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4924       return FALSE;
4925     }
4926   if (size > sizeof * phdrs)
4927     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4928
4929   phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4930                                             size, num, _("program headers"));
4931   if (!phdrs)
4932     return FALSE;
4933
4934   for (i = 0, internal = pheaders, external = phdrs;
4935        i < filedata->file_header.e_phnum;
4936        i++, internal++, external++)
4937     {
4938       internal->p_type   = BYTE_GET (external->p_type);
4939       internal->p_flags  = BYTE_GET (external->p_flags);
4940       internal->p_offset = BYTE_GET (external->p_offset);
4941       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4942       internal->p_paddr  = BYTE_GET (external->p_paddr);
4943       internal->p_filesz = BYTE_GET (external->p_filesz);
4944       internal->p_memsz  = BYTE_GET (external->p_memsz);
4945       internal->p_align  = BYTE_GET (external->p_align);
4946     }
4947
4948   free (phdrs);
4949   return TRUE;
4950 }
4951
4952 /* Returns TRUE if the program headers were read into `program_headers'.  */
4953
4954 static bfd_boolean
4955 get_program_headers (Filedata * filedata)
4956 {
4957   Elf_Internal_Phdr * phdrs;
4958
4959   /* Check cache of prior read.  */
4960   if (filedata->program_headers != NULL)
4961     return TRUE;
4962
4963   /* Be kind to memory checkers by looking for
4964      e_phnum values which we know must be invalid.  */
4965   if (filedata->file_header.e_phnum
4966       * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
4967       >= filedata->file_size)
4968     {
4969       error (_("Too many program headers - %#x - the file is not that big\n"),
4970              filedata->file_header.e_phnum);
4971       return FALSE;
4972     }
4973
4974   phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
4975                                          sizeof (Elf_Internal_Phdr));
4976   if (phdrs == NULL)
4977     {
4978       error (_("Out of memory reading %u program headers\n"),
4979              filedata->file_header.e_phnum);
4980       return FALSE;
4981     }
4982
4983   if (is_32bit_elf
4984       ? get_32bit_program_headers (filedata, phdrs)
4985       : get_64bit_program_headers (filedata, phdrs))
4986     {
4987       filedata->program_headers = phdrs;
4988       return TRUE;
4989     }
4990
4991   free (phdrs);
4992   return FALSE;
4993 }
4994
4995 /* Returns TRUE if the program headers were loaded.  */
4996
4997 static bfd_boolean
4998 process_program_headers (Filedata * filedata)
4999 {
5000   Elf_Internal_Phdr * segment;
5001   unsigned int i;
5002   Elf_Internal_Phdr * previous_load = NULL;
5003
5004   if (filedata->file_header.e_phnum == 0)
5005     {
5006       /* PR binutils/12467.  */
5007       if (filedata->file_header.e_phoff != 0)
5008         {
5009           warn (_("possibly corrupt ELF header - it has a non-zero program"
5010                   " header offset, but no program headers\n"));
5011           return FALSE;
5012         }
5013       else if (do_segments)
5014         printf (_("\nThere are no program headers in this file.\n"));
5015       return TRUE;
5016     }
5017
5018   if (do_segments && !do_header)
5019     {
5020       printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
5021       printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
5022       printf (ngettext ("There is %d program header, starting at offset %s\n",
5023                         "There are %d program headers, starting at offset %s\n",
5024                         filedata->file_header.e_phnum),
5025               filedata->file_header.e_phnum,
5026               bfd_vmatoa ("u", filedata->file_header.e_phoff));
5027     }
5028
5029   if (! get_program_headers (filedata))
5030     return TRUE;
5031
5032   if (do_segments)
5033     {
5034       if (filedata->file_header.e_phnum > 1)
5035         printf (_("\nProgram Headers:\n"));
5036       else
5037         printf (_("\nProgram Headers:\n"));
5038
5039       if (is_32bit_elf)
5040         printf
5041           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
5042       else if (do_wide)
5043         printf
5044           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
5045       else
5046         {
5047           printf
5048             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
5049           printf
5050             (_("                 FileSiz            MemSiz              Flags  Align\n"));
5051         }
5052     }
5053
5054   dynamic_addr = 0;
5055   dynamic_size = 0;
5056
5057   for (i = 0, segment = filedata->program_headers;
5058        i < filedata->file_header.e_phnum;
5059        i++, segment++)
5060     {
5061       if (do_segments)
5062         {
5063           printf ("  %-14.14s ", get_segment_type (filedata, segment->p_type));
5064
5065           if (is_32bit_elf)
5066             {
5067               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5068               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
5069               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
5070               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
5071               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
5072               printf ("%c%c%c ",
5073                       (segment->p_flags & PF_R ? 'R' : ' '),
5074                       (segment->p_flags & PF_W ? 'W' : ' '),
5075                       (segment->p_flags & PF_X ? 'E' : ' '));
5076               printf ("%#lx", (unsigned long) segment->p_align);
5077             }
5078           else if (do_wide)
5079             {
5080               if ((unsigned long) segment->p_offset == segment->p_offset)
5081                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5082               else
5083                 {
5084                   print_vma (segment->p_offset, FULL_HEX);
5085                   putchar (' ');
5086                 }
5087
5088               print_vma (segment->p_vaddr, FULL_HEX);
5089               putchar (' ');
5090               print_vma (segment->p_paddr, FULL_HEX);
5091               putchar (' ');
5092
5093               if ((unsigned long) segment->p_filesz == segment->p_filesz)
5094                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
5095               else
5096                 {
5097                   print_vma (segment->p_filesz, FULL_HEX);
5098                   putchar (' ');
5099                 }
5100
5101               if ((unsigned long) segment->p_memsz == segment->p_memsz)
5102                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5103               else
5104                 {
5105                   print_vma (segment->p_memsz, FULL_HEX);
5106                 }
5107
5108               printf (" %c%c%c ",
5109                       (segment->p_flags & PF_R ? 'R' : ' '),
5110                       (segment->p_flags & PF_W ? 'W' : ' '),
5111                       (segment->p_flags & PF_X ? 'E' : ' '));
5112
5113               if ((unsigned long) segment->p_align == segment->p_align)
5114                 printf ("%#lx", (unsigned long) segment->p_align);
5115               else
5116                 {
5117                   print_vma (segment->p_align, PREFIX_HEX);
5118                 }
5119             }
5120           else
5121             {
5122               print_vma (segment->p_offset, FULL_HEX);
5123               putchar (' ');
5124               print_vma (segment->p_vaddr, FULL_HEX);
5125               putchar (' ');
5126               print_vma (segment->p_paddr, FULL_HEX);
5127               printf ("\n                 ");
5128               print_vma (segment->p_filesz, FULL_HEX);
5129               putchar (' ');
5130               print_vma (segment->p_memsz, FULL_HEX);
5131               printf ("  %c%c%c    ",
5132                       (segment->p_flags & PF_R ? 'R' : ' '),
5133                       (segment->p_flags & PF_W ? 'W' : ' '),
5134                       (segment->p_flags & PF_X ? 'E' : ' '));
5135               print_vma (segment->p_align, PREFIX_HEX);
5136             }
5137
5138           putc ('\n', stdout);
5139         }
5140
5141       switch (segment->p_type)
5142         {
5143         case PT_LOAD:
5144 #if 0 /* Do not warn about out of order PT_LOAD segments.  Although officially
5145          required by the ELF standard, several programs, including the Linux
5146          kernel, make use of non-ordered segments.  */
5147           if (previous_load
5148               && previous_load->p_vaddr > segment->p_vaddr)
5149             error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5150 #endif
5151           if (segment->p_memsz < segment->p_filesz)
5152             error (_("the segment's file size is larger than its memory size\n"));
5153           previous_load = segment;
5154           break;
5155
5156         case PT_PHDR:
5157           /* PR 20815 - Verify that the program header is loaded into memory.  */
5158           if (i > 0 && previous_load != NULL)
5159             error (_("the PHDR segment must occur before any LOAD segment\n"));
5160           if (filedata->file_header.e_machine != EM_PARISC)
5161             {
5162               unsigned int j;
5163
5164               for (j = 1; j < filedata->file_header.e_phnum; j++)
5165                 if (filedata->program_headers[j].p_vaddr <= segment->p_vaddr
5166                     && (filedata->program_headers[j].p_vaddr
5167                         + filedata->program_headers[j].p_memsz)
5168                     >= (segment->p_vaddr + segment->p_filesz))
5169                   break;
5170               if (j == filedata->file_header.e_phnum)
5171                 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5172             }
5173           break;
5174
5175         case PT_DYNAMIC:
5176           if (dynamic_addr)
5177             error (_("more than one dynamic segment\n"));
5178
5179           /* By default, assume that the .dynamic section is the first
5180              section in the DYNAMIC segment.  */
5181           dynamic_addr = segment->p_offset;
5182           dynamic_size = segment->p_filesz;
5183
5184           /* Try to locate the .dynamic section. If there is
5185              a section header table, we can easily locate it.  */
5186           if (filedata->section_headers != NULL)
5187             {
5188               Elf_Internal_Shdr * sec;
5189
5190               sec = find_section (filedata, ".dynamic");
5191               if (sec == NULL || sec->sh_size == 0)
5192                 {
5193                   /* A corresponding .dynamic section is expected, but on
5194                      IA-64/OpenVMS it is OK for it to be missing.  */
5195                   if (!is_ia64_vms (filedata))
5196                     error (_("no .dynamic section in the dynamic segment\n"));
5197                   break;
5198                 }
5199
5200               if (sec->sh_type == SHT_NOBITS)
5201                 {
5202                   dynamic_size = 0;
5203                   break;
5204                 }
5205
5206               dynamic_addr = sec->sh_offset;
5207               dynamic_size = sec->sh_size;
5208
5209               if (dynamic_addr < segment->p_offset
5210                   || dynamic_addr > segment->p_offset + segment->p_filesz)
5211                 warn (_("the .dynamic section is not contained"
5212                         " within the dynamic segment\n"));
5213               else if (dynamic_addr > segment->p_offset)
5214                 warn (_("the .dynamic section is not the first section"
5215                         " in the dynamic segment.\n"));
5216             }
5217
5218           /* PR binutils/17512: Avoid corrupt dynamic section info in the
5219              segment.  Check this after matching against the section headers
5220              so we don't warn on debuginfo file (which have NOBITS .dynamic
5221              sections).  */
5222           if (dynamic_addr + dynamic_size >= filedata->file_size)
5223             {
5224               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5225               dynamic_addr = dynamic_size = 0;
5226             }
5227           break;
5228
5229         case PT_INTERP:
5230           if (fseek (filedata->handle, archive_file_offset + (long) segment->p_offset,
5231                      SEEK_SET))
5232             error (_("Unable to find program interpreter name\n"));
5233           else
5234             {
5235               char fmt [32];
5236               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5237
5238               if (ret >= (int) sizeof (fmt) || ret < 0)
5239                 error (_("Internal error: failed to create format string to display program interpreter\n"));
5240
5241               program_interpreter[0] = 0;
5242               if (fscanf (filedata->handle, fmt, program_interpreter) <= 0)
5243                 error (_("Unable to read program interpreter name\n"));
5244
5245               if (do_segments)
5246                 printf (_("      [Requesting program interpreter: %s]\n"),
5247                     program_interpreter);
5248             }
5249           break;
5250         }
5251     }
5252
5253   if (do_segments
5254       && filedata->section_headers != NULL
5255       && filedata->string_table != NULL)
5256     {
5257       printf (_("\n Section to Segment mapping:\n"));
5258       printf (_("  Segment Sections...\n"));
5259
5260       for (i = 0; i < filedata->file_header.e_phnum; i++)
5261         {
5262           unsigned int j;
5263           Elf_Internal_Shdr * section;
5264
5265           segment = filedata->program_headers + i;
5266           section = filedata->section_headers + 1;
5267
5268           printf ("   %2.2d     ", i);
5269
5270           for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
5271             {
5272               if (!ELF_TBSS_SPECIAL (section, segment)
5273                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5274                 printf ("%s ", printable_section_name (filedata, section));
5275             }
5276
5277           putc ('\n',stdout);
5278         }
5279     }
5280
5281   return TRUE;
5282 }
5283
5284
5285 /* Find the file offset corresponding to VMA by using the program headers.  */
5286
5287 static long
5288 offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
5289 {
5290   Elf_Internal_Phdr * seg;
5291
5292   if (! get_program_headers (filedata))
5293     {
5294       warn (_("Cannot interpret virtual addresses without program headers.\n"));
5295       return (long) vma;
5296     }
5297
5298   for (seg = filedata->program_headers;
5299        seg < filedata->program_headers + filedata->file_header.e_phnum;
5300        ++seg)
5301     {
5302       if (seg->p_type != PT_LOAD)
5303         continue;
5304
5305       if (vma >= (seg->p_vaddr & -seg->p_align)
5306           && vma + size <= seg->p_vaddr + seg->p_filesz)
5307         return vma - seg->p_vaddr + seg->p_offset;
5308     }
5309
5310   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5311         (unsigned long) vma);
5312   return (long) vma;
5313 }
5314
5315
5316 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5317    If PROBE is true, this is just a probe and we do not generate any error
5318    messages if the load fails.  */
5319
5320 static bfd_boolean
5321 get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
5322 {
5323   Elf32_External_Shdr * shdrs;
5324   Elf_Internal_Shdr *   internal;
5325   unsigned int          i;
5326   unsigned int          size = filedata->file_header.e_shentsize;
5327   unsigned int          num = probe ? 1 : filedata->file_header.e_shnum;
5328
5329   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5330   if (size == 0 || num == 0)
5331     return FALSE;
5332   if (size < sizeof * shdrs)
5333     {
5334       if (! probe)
5335         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5336       return FALSE;
5337     }
5338   if (!probe && size > sizeof * shdrs)
5339     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5340
5341   shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
5342                                             size, num,
5343                                             probe ? NULL : _("section headers"));
5344   if (shdrs == NULL)
5345     return FALSE;
5346
5347   free (filedata->section_headers);
5348   filedata->section_headers = (Elf_Internal_Shdr *)
5349     cmalloc (num, sizeof (Elf_Internal_Shdr));
5350   if (filedata->section_headers == NULL)
5351     {
5352       if (!probe)
5353         error (_("Out of memory reading %u section headers\n"), num);
5354       free (shdrs);
5355       return FALSE;
5356     }
5357
5358   for (i = 0, internal = filedata->section_headers;
5359        i < num;
5360        i++, internal++)
5361     {
5362       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5363       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5364       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5365       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5366       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5367       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5368       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5369       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5370       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5371       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5372       if (!probe && internal->sh_link > num)
5373         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5374       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5375         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5376     }
5377
5378   free (shdrs);
5379   return TRUE;
5380 }
5381
5382 /* Like get_32bit_section_headers, except that it fetches 64-bit headers.  */
5383
5384 static bfd_boolean
5385 get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
5386 {
5387   Elf64_External_Shdr *  shdrs;
5388   Elf_Internal_Shdr *    internal;
5389   unsigned int           i;
5390   unsigned int           size = filedata->file_header.e_shentsize;
5391   unsigned int           num = probe ? 1 : filedata->file_header.e_shnum;
5392
5393   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5394   if (size == 0 || num == 0)
5395     return FALSE;
5396
5397   if (size < sizeof * shdrs)
5398     {
5399       if (! probe)
5400         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5401       return FALSE;
5402     }
5403
5404   if (! probe && size > sizeof * shdrs)
5405     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5406
5407   shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
5408                                             filedata->file_header.e_shoff,
5409                                             size, num,
5410                                             probe ? NULL : _("section headers"));
5411   if (shdrs == NULL)
5412     return FALSE;
5413
5414   free (filedata->section_headers);
5415   filedata->section_headers = (Elf_Internal_Shdr *)
5416     cmalloc (num, sizeof (Elf_Internal_Shdr));
5417   if (filedata->section_headers == NULL)
5418     {
5419       if (! probe)
5420         error (_("Out of memory reading %u section headers\n"), num);
5421       free (shdrs);
5422       return FALSE;
5423     }
5424
5425   for (i = 0, internal = filedata->section_headers;
5426        i < num;
5427        i++, internal++)
5428     {
5429       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5430       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5431       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5432       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5433       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5434       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5435       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5436       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5437       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5438       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5439       if (!probe && internal->sh_link > num)
5440         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5441       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5442         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5443     }
5444
5445   free (shdrs);
5446   return TRUE;
5447 }
5448
5449 static Elf_Internal_Sym *
5450 get_32bit_elf_symbols (Filedata *           filedata,
5451                        Elf_Internal_Shdr *  section,
5452                        unsigned long *      num_syms_return)
5453 {
5454   unsigned long number = 0;
5455   Elf32_External_Sym * esyms = NULL;
5456   Elf_External_Sym_Shndx * shndx = NULL;
5457   Elf_Internal_Sym * isyms = NULL;
5458   Elf_Internal_Sym * psym;
5459   unsigned int j;
5460   elf_section_list * entry;
5461
5462   if (section->sh_size == 0)
5463     {
5464       if (num_syms_return != NULL)
5465         * num_syms_return = 0;
5466       return NULL;
5467     }
5468
5469   /* Run some sanity checks first.  */
5470   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5471     {
5472       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5473              printable_section_name (filedata, section),
5474              (unsigned long) section->sh_entsize);
5475       goto exit_point;
5476     }
5477
5478   if (section->sh_size > filedata->file_size)
5479     {
5480       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5481              printable_section_name (filedata, section),
5482              (unsigned long) section->sh_size);
5483       goto exit_point;
5484     }
5485
5486   number = section->sh_size / section->sh_entsize;
5487
5488   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5489     {
5490       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5491              (unsigned long) section->sh_size,
5492              printable_section_name (filedata, section),
5493              (unsigned long) section->sh_entsize);
5494       goto exit_point;
5495     }
5496
5497   esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5498                                            section->sh_size, _("symbols"));
5499   if (esyms == NULL)
5500     goto exit_point;
5501
5502   shndx = NULL;
5503   for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5504     {
5505       if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5506         continue;
5507
5508       if (shndx != NULL)
5509         {
5510           error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5511           free (shndx);
5512         }
5513
5514       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5515                                                    entry->hdr->sh_offset,
5516                                                    1, entry->hdr->sh_size,
5517                                                    _("symbol table section indices"));
5518       if (shndx == NULL)
5519         goto exit_point;
5520
5521       /* PR17531: file: heap-buffer-overflow */
5522       if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5523         {
5524           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5525                  printable_section_name (filedata, entry->hdr),
5526                  (unsigned long) entry->hdr->sh_size,
5527                  (unsigned long) section->sh_size);
5528           goto exit_point;
5529         }
5530     }
5531
5532   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5533
5534   if (isyms == NULL)
5535     {
5536       error (_("Out of memory reading %lu symbols\n"),
5537              (unsigned long) number);
5538       goto exit_point;
5539     }
5540
5541   for (j = 0, psym = isyms; j < number; j++, psym++)
5542     {
5543       psym->st_name  = BYTE_GET (esyms[j].st_name);
5544       psym->st_value = BYTE_GET (esyms[j].st_value);
5545       psym->st_size  = BYTE_GET (esyms[j].st_size);
5546       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5547       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5548         psym->st_shndx
5549           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5550       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5551         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5552       psym->st_info  = BYTE_GET (esyms[j].st_info);
5553       psym->st_other = BYTE_GET (esyms[j].st_other);
5554     }
5555
5556  exit_point:
5557   free (shndx);
5558   free (esyms);
5559
5560   if (num_syms_return != NULL)
5561     * num_syms_return = isyms == NULL ? 0 : number;
5562
5563   return isyms;
5564 }
5565
5566 static Elf_Internal_Sym *
5567 get_64bit_elf_symbols (Filedata *           filedata,
5568                        Elf_Internal_Shdr *  section,
5569                        unsigned long *      num_syms_return)
5570 {
5571   unsigned long number = 0;
5572   Elf64_External_Sym * esyms = NULL;
5573   Elf_External_Sym_Shndx * shndx = NULL;
5574   Elf_Internal_Sym * isyms = NULL;
5575   Elf_Internal_Sym * psym;
5576   unsigned int j;
5577   elf_section_list * entry;
5578
5579   if (section->sh_size == 0)
5580     {
5581       if (num_syms_return != NULL)
5582         * num_syms_return = 0;
5583       return NULL;
5584     }
5585
5586   /* Run some sanity checks first.  */
5587   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5588     {
5589       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5590              printable_section_name (filedata, section),
5591              (unsigned long) section->sh_entsize);
5592       goto exit_point;
5593     }
5594
5595   if (section->sh_size > filedata->file_size)
5596     {
5597       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5598              printable_section_name (filedata, section),
5599              (unsigned long) section->sh_size);
5600       goto exit_point;
5601     }
5602
5603   number = section->sh_size / section->sh_entsize;
5604
5605   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5606     {
5607       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5608              (unsigned long) section->sh_size,
5609              printable_section_name (filedata, section),
5610              (unsigned long) section->sh_entsize);
5611       goto exit_point;
5612     }
5613
5614   esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5615                                            section->sh_size, _("symbols"));
5616   if (!esyms)
5617     goto exit_point;
5618
5619   shndx = NULL;
5620   for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5621     {
5622       if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5623         continue;
5624
5625       if (shndx != NULL)
5626         {
5627           error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5628           free (shndx);
5629         }
5630
5631       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5632                                                    entry->hdr->sh_offset,
5633                                                    1, entry->hdr->sh_size,
5634                                                    _("symbol table section indices"));
5635       if (shndx == NULL)
5636         goto exit_point;
5637
5638       /* PR17531: file: heap-buffer-overflow */
5639       if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5640         {
5641           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5642                  printable_section_name (filedata, entry->hdr),
5643                  (unsigned long) entry->hdr->sh_size,
5644                  (unsigned long) section->sh_size);
5645           goto exit_point;
5646         }
5647     }
5648
5649   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5650
5651   if (isyms == NULL)
5652     {
5653       error (_("Out of memory reading %lu symbols\n"),
5654              (unsigned long) number);
5655       goto exit_point;
5656     }
5657
5658   for (j = 0, psym = isyms; j < number; j++, psym++)
5659     {
5660       psym->st_name  = BYTE_GET (esyms[j].st_name);
5661       psym->st_info  = BYTE_GET (esyms[j].st_info);
5662       psym->st_other = BYTE_GET (esyms[j].st_other);
5663       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5664
5665       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5666         psym->st_shndx
5667           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5668       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5669         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5670
5671       psym->st_value = BYTE_GET (esyms[j].st_value);
5672       psym->st_size  = BYTE_GET (esyms[j].st_size);
5673     }
5674
5675  exit_point:
5676   free (shndx);
5677   free (esyms);
5678
5679   if (num_syms_return != NULL)
5680     * num_syms_return = isyms == NULL ? 0 : number;
5681
5682   return isyms;
5683 }
5684
5685 static const char *
5686 get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
5687 {
5688   static char buff[1024];
5689   char * p = buff;
5690   unsigned int field_size = is_32bit_elf ? 8 : 16;
5691   signed int sindex;
5692   unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5693   bfd_vma os_flags = 0;
5694   bfd_vma proc_flags = 0;
5695   bfd_vma unknown_flags = 0;
5696   static const struct
5697     {
5698       const char * str;
5699       unsigned int len;
5700     }
5701   flags [] =
5702     {
5703       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5704       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5705       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5706       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5707       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5708       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5709       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5710       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5711       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5712       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5713       /* IA-64 specific.  */
5714       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5715       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5716       /* IA-64 OpenVMS specific.  */
5717       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5718       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5719       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5720       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5721       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5722       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5723       /* Generic.  */
5724       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5725       /* SPARC specific.  */
5726       /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5727       /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5728       /* ARM specific.  */
5729       /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5730       /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5731       /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5732       /* GNU specific.  */
5733       /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5734       /* VLE specific.  */
5735       /* 25 */ { STRING_COMMA_LEN ("VLE") },
5736     };
5737
5738   if (do_section_details)
5739     {
5740       sprintf (buff, "[%*.*lx]: ",
5741                field_size, field_size, (unsigned long) sh_flags);
5742       p += field_size + 4;
5743     }
5744
5745   while (sh_flags)
5746     {
5747       bfd_vma flag;
5748
5749       flag = sh_flags & - sh_flags;
5750       sh_flags &= ~ flag;
5751
5752       if (do_section_details)
5753         {
5754           switch (flag)
5755             {
5756             case SHF_WRITE:             sindex = 0; break;
5757             case SHF_ALLOC:             sindex = 1; break;
5758             case SHF_EXECINSTR:         sindex = 2; break;
5759             case SHF_MERGE:             sindex = 3; break;
5760             case SHF_STRINGS:           sindex = 4; break;
5761             case SHF_INFO_LINK:         sindex = 5; break;
5762             case SHF_LINK_ORDER:        sindex = 6; break;
5763             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5764             case SHF_GROUP:             sindex = 8; break;
5765             case SHF_TLS:               sindex = 9; break;
5766             case SHF_EXCLUDE:           sindex = 18; break;
5767             case SHF_COMPRESSED:        sindex = 20; break;
5768             case SHF_GNU_MBIND:         sindex = 24; break;
5769
5770             default:
5771               sindex = -1;
5772               switch (filedata->file_header.e_machine)
5773                 {
5774                 case EM_IA_64:
5775                   if (flag == SHF_IA_64_SHORT)
5776                     sindex = 10;
5777                   else if (flag == SHF_IA_64_NORECOV)
5778                     sindex = 11;
5779 #ifdef BFD64
5780                   else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5781                     switch (flag)
5782                       {
5783                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5784                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5785                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5786                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5787                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5788                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5789                       default:                        break;
5790                       }
5791 #endif
5792                   break;
5793
5794                 case EM_386:
5795                 case EM_IAMCU:
5796                 case EM_X86_64:
5797                 case EM_L1OM:
5798                 case EM_K1OM:
5799                 case EM_OLD_SPARCV9:
5800                 case EM_SPARC32PLUS:
5801                 case EM_SPARCV9:
5802                 case EM_SPARC:
5803                   if (flag == SHF_ORDERED)
5804                     sindex = 19;
5805                   break;
5806
5807                 case EM_ARM:
5808                   switch (flag)
5809                     {
5810                     case SHF_ENTRYSECT: sindex = 21; break;
5811                     case SHF_ARM_PURECODE: sindex = 22; break;
5812                     case SHF_COMDEF: sindex = 23; break;
5813                     default: break;
5814                     }
5815                   break;
5816                 case EM_PPC:
5817                   if (flag == SHF_PPC_VLE)
5818                     sindex = 25;
5819                   break;
5820
5821                 default:
5822                   break;
5823                 }
5824             }
5825
5826           if (sindex != -1)
5827             {
5828               if (p != buff + field_size + 4)
5829                 {
5830                   if (size < (10 + 2))
5831                     {
5832                       warn (_("Internal error: not enough buffer room for section flag info"));
5833                       return _("<unknown>");
5834                     }
5835                   size -= 2;
5836                   *p++ = ',';
5837                   *p++ = ' ';
5838                 }
5839
5840               size -= flags [sindex].len;
5841               p = stpcpy (p, flags [sindex].str);
5842             }
5843           else if (flag & SHF_MASKOS)
5844             os_flags |= flag;
5845           else if (flag & SHF_MASKPROC)
5846             proc_flags |= flag;
5847           else
5848             unknown_flags |= flag;
5849         }
5850       else
5851         {
5852           switch (flag)
5853             {
5854             case SHF_WRITE:             *p = 'W'; break;
5855             case SHF_ALLOC:             *p = 'A'; break;
5856             case SHF_EXECINSTR:         *p = 'X'; break;
5857             case SHF_MERGE:             *p = 'M'; break;
5858             case SHF_STRINGS:           *p = 'S'; break;
5859             case SHF_INFO_LINK:         *p = 'I'; break;
5860             case SHF_LINK_ORDER:        *p = 'L'; break;
5861             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5862             case SHF_GROUP:             *p = 'G'; break;
5863             case SHF_TLS:               *p = 'T'; break;
5864             case SHF_EXCLUDE:           *p = 'E'; break;
5865             case SHF_COMPRESSED:        *p = 'C'; break;
5866             case SHF_GNU_MBIND:         *p = 'D'; break;
5867
5868             default:
5869               if ((filedata->file_header.e_machine == EM_X86_64
5870                    || filedata->file_header.e_machine == EM_L1OM
5871                    || filedata->file_header.e_machine == EM_K1OM)
5872                   && flag == SHF_X86_64_LARGE)
5873                 *p = 'l';
5874               else if (filedata->file_header.e_machine == EM_ARM
5875                        && flag == SHF_ARM_PURECODE)
5876                   *p = 'y';
5877               else if (filedata->file_header.e_machine == EM_PPC
5878                        && flag == SHF_PPC_VLE)
5879                   *p = 'v';
5880               else if (flag & SHF_MASKOS)
5881                 {
5882                   *p = 'o';
5883                   sh_flags &= ~ SHF_MASKOS;
5884                 }
5885               else if (flag & SHF_MASKPROC)
5886                 {
5887                   *p = 'p';
5888                   sh_flags &= ~ SHF_MASKPROC;
5889                 }
5890               else
5891                 *p = 'x';
5892               break;
5893             }
5894           p++;
5895         }
5896     }
5897
5898   if (do_section_details)
5899     {
5900       if (os_flags)
5901         {
5902           size -= 5 + field_size;
5903           if (p != buff + field_size + 4)
5904             {
5905               if (size < (2 + 1))
5906                 {
5907                   warn (_("Internal error: not enough buffer room for section flag info"));
5908                   return _("<unknown>");
5909                 }
5910               size -= 2;
5911               *p++ = ',';
5912               *p++ = ' ';
5913             }
5914           sprintf (p, "OS (%*.*lx)", field_size, field_size,
5915                    (unsigned long) os_flags);
5916           p += 5 + field_size;
5917         }
5918       if (proc_flags)
5919         {
5920           size -= 7 + field_size;
5921           if (p != buff + field_size + 4)
5922             {
5923               if (size < (2 + 1))
5924                 {
5925                   warn (_("Internal error: not enough buffer room for section flag info"));
5926                   return _("<unknown>");
5927                 }
5928               size -= 2;
5929               *p++ = ',';
5930               *p++ = ' ';
5931             }
5932           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5933                    (unsigned long) proc_flags);
5934           p += 7 + field_size;
5935         }
5936       if (unknown_flags)
5937         {
5938           size -= 10 + field_size;
5939           if (p != buff + field_size + 4)
5940             {
5941               if (size < (2 + 1))
5942                 {
5943                   warn (_("Internal error: not enough buffer room for section flag info"));
5944                   return _("<unknown>");
5945                 }
5946               size -= 2;
5947               *p++ = ',';
5948               *p++ = ' ';
5949             }
5950           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5951                    (unsigned long) unknown_flags);
5952           p += 10 + field_size;
5953         }
5954     }
5955
5956   *p = '\0';
5957   return buff;
5958 }
5959
5960 static unsigned int
5961 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
5962 {
5963   if (is_32bit_elf)
5964     {
5965       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5966
5967       if (size < sizeof (* echdr))
5968         {
5969           error (_("Compressed section is too small even for a compression header\n"));
5970           return 0;
5971         }
5972
5973       chdr->ch_type = BYTE_GET (echdr->ch_type);
5974       chdr->ch_size = BYTE_GET (echdr->ch_size);
5975       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5976       return sizeof (*echdr);
5977     }
5978   else
5979     {
5980       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5981
5982       if (size < sizeof (* echdr))
5983         {
5984           error (_("Compressed section is too small even for a compression header\n"));
5985           return 0;
5986         }
5987
5988       chdr->ch_type = BYTE_GET (echdr->ch_type);
5989       chdr->ch_size = BYTE_GET (echdr->ch_size);
5990       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5991       return sizeof (*echdr);
5992     }
5993 }
5994
5995 static bfd_boolean
5996 process_section_headers (Filedata * filedata)
5997 {
5998   Elf_Internal_Shdr * section;
5999   unsigned int i;
6000
6001   filedata->section_headers = NULL;
6002
6003   if (filedata->file_header.e_shnum == 0)
6004     {
6005       /* PR binutils/12467.  */
6006       if (filedata->file_header.e_shoff != 0)
6007         {
6008           warn (_("possibly corrupt ELF file header - it has a non-zero"
6009                   " section header offset, but no section headers\n"));
6010           return FALSE;
6011         }
6012       else if (do_sections)
6013         printf (_("\nThere are no sections in this file.\n"));
6014
6015       return TRUE;
6016     }
6017
6018   if (do_sections && !do_header)
6019     printf (ngettext ("There is %d section header, "
6020                       "starting at offset 0x%lx:\n",
6021                       "There are %d section headers, "
6022                       "starting at offset 0x%lx:\n",
6023                       filedata->file_header.e_shnum),
6024             filedata->file_header.e_shnum,
6025             (unsigned long) filedata->file_header.e_shoff);
6026
6027   if (is_32bit_elf)
6028     {
6029       if (! get_32bit_section_headers (filedata, FALSE))
6030         return FALSE;
6031     }
6032   else
6033     {
6034       if (! get_64bit_section_headers (filedata, FALSE))
6035         return FALSE;
6036     }
6037
6038   /* Read in the string table, so that we have names to display.  */
6039   if (filedata->file_header.e_shstrndx != SHN_UNDEF
6040        && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
6041     {
6042       section = filedata->section_headers + filedata->file_header.e_shstrndx;
6043
6044       if (section->sh_size != 0)
6045         {
6046           filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
6047                                                       1, section->sh_size,
6048                                                       _("string table"));
6049
6050           filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
6051         }
6052     }
6053
6054   /* Scan the sections for the dynamic symbol table
6055      and dynamic string table and debug sections.  */
6056   dynamic_symbols = NULL;
6057   dynamic_strings = NULL;
6058   dynamic_syminfo = NULL;
6059   symtab_shndx_list = NULL;
6060
6061   eh_addr_size = is_32bit_elf ? 4 : 8;
6062   switch (filedata->file_header.e_machine)
6063     {
6064     case EM_MIPS:
6065     case EM_MIPS_RS3_LE:
6066       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6067          FDE addresses.  However, the ABI also has a semi-official ILP32
6068          variant for which the normal FDE address size rules apply.
6069
6070          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6071          section, where XX is the size of longs in bits.  Unfortunately,
6072          earlier compilers provided no way of distinguishing ILP32 objects
6073          from LP64 objects, so if there's any doubt, we should assume that
6074          the official LP64 form is being used.  */
6075       if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
6076           && find_section (filedata, ".gcc_compiled_long32") == NULL)
6077         eh_addr_size = 8;
6078       break;
6079
6080     case EM_H8_300:
6081     case EM_H8_300H:
6082       switch (filedata->file_header.e_flags & EF_H8_MACH)
6083         {
6084         case E_H8_MACH_H8300:
6085         case E_H8_MACH_H8300HN:
6086         case E_H8_MACH_H8300SN:
6087         case E_H8_MACH_H8300SXN:
6088           eh_addr_size = 2;
6089           break;
6090         case E_H8_MACH_H8300H:
6091         case E_H8_MACH_H8300S:
6092         case E_H8_MACH_H8300SX:
6093           eh_addr_size = 4;
6094           break;
6095         }
6096       break;
6097
6098     case EM_M32C_OLD:
6099     case EM_M32C:
6100       switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
6101         {
6102         case EF_M32C_CPU_M16C:
6103           eh_addr_size = 2;
6104           break;
6105         }
6106       break;
6107     }
6108
6109 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
6110   do                                                                    \
6111     {                                                                   \
6112       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
6113       if (section->sh_entsize != expected_entsize)                      \
6114         {                                                               \
6115           char buf[40];                                                 \
6116           sprintf_vma (buf, section->sh_entsize);                       \
6117           /* Note: coded this way so that there is a single string for  \
6118              translation.  */ \
6119           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6120           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6121                    (unsigned) expected_entsize);                        \
6122           section->sh_entsize = expected_entsize;                       \
6123         }                                                               \
6124     }                                                                   \
6125   while (0)
6126
6127 #define CHECK_ENTSIZE(section, i, type)                                 \
6128   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
6129                         sizeof (Elf64_External_##type))
6130
6131   for (i = 0, section = filedata->section_headers;
6132        i < filedata->file_header.e_shnum;
6133        i++, section++)
6134     {
6135       char * name = SECTION_NAME (section);
6136
6137       if (section->sh_type == SHT_DYNSYM)
6138         {
6139           if (dynamic_symbols != NULL)
6140             {
6141               error (_("File contains multiple dynamic symbol tables\n"));
6142               continue;
6143             }
6144
6145           CHECK_ENTSIZE (section, i, Sym);
6146           dynamic_symbols = GET_ELF_SYMBOLS (filedata, section, & num_dynamic_syms);
6147         }
6148       else if (section->sh_type == SHT_STRTAB
6149                && streq (name, ".dynstr"))
6150         {
6151           if (dynamic_strings != NULL)
6152             {
6153               error (_("File contains multiple dynamic string tables\n"));
6154               continue;
6155             }
6156
6157           dynamic_strings = (char *) get_data (NULL, filedata, section->sh_offset,
6158                                                1, section->sh_size,
6159                                                _("dynamic strings"));
6160           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6161         }
6162       else if (section->sh_type == SHT_SYMTAB_SHNDX)
6163         {
6164           elf_section_list * entry = xmalloc (sizeof * entry);
6165
6166           entry->hdr = section;
6167           entry->next = symtab_shndx_list;
6168           symtab_shndx_list = entry;
6169         }
6170       else if (section->sh_type == SHT_SYMTAB)
6171         CHECK_ENTSIZE (section, i, Sym);
6172       else if (section->sh_type == SHT_GROUP)
6173         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6174       else if (section->sh_type == SHT_REL)
6175         CHECK_ENTSIZE (section, i, Rel);
6176       else if (section->sh_type == SHT_RELA)
6177         CHECK_ENTSIZE (section, i, Rela);
6178       else if ((do_debugging || do_debug_info || do_debug_abbrevs
6179                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6180                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6181                 || do_debug_str || do_debug_loc || do_debug_ranges
6182                 || do_debug_addr || do_debug_cu_index || do_debug_links)
6183                && (const_strneq (name, ".debug_")
6184                    || const_strneq (name, ".zdebug_")))
6185         {
6186           if (name[1] == 'z')
6187             name += sizeof (".zdebug_") - 1;
6188           else
6189             name += sizeof (".debug_") - 1;
6190
6191           if (do_debugging
6192               || (do_debug_info     && const_strneq (name, "info"))
6193               || (do_debug_info     && const_strneq (name, "types"))
6194               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
6195               || (do_debug_lines    && strcmp (name, "line") == 0)
6196               || (do_debug_lines    && const_strneq (name, "line."))
6197               || (do_debug_pubnames && const_strneq (name, "pubnames"))
6198               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6199               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6200               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6201               || (do_debug_aranges  && const_strneq (name, "aranges"))
6202               || (do_debug_ranges   && const_strneq (name, "ranges"))
6203               || (do_debug_ranges   && const_strneq (name, "rnglists"))
6204               || (do_debug_frames   && const_strneq (name, "frame"))
6205               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
6206               || (do_debug_macinfo  && const_strneq (name, "macro"))
6207               || (do_debug_str      && const_strneq (name, "str"))
6208               || (do_debug_loc      && const_strneq (name, "loc"))
6209               || (do_debug_loc      && const_strneq (name, "loclists"))
6210               || (do_debug_addr     && const_strneq (name, "addr"))
6211               || (do_debug_cu_index && const_strneq (name, "cu_index"))
6212               || (do_debug_cu_index && const_strneq (name, "tu_index"))
6213               )
6214             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6215         }
6216       /* Linkonce section to be combined with .debug_info at link time.  */
6217       else if ((do_debugging || do_debug_info)
6218                && const_strneq (name, ".gnu.linkonce.wi."))
6219         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6220       else if (do_debug_frames && streq (name, ".eh_frame"))
6221         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6222       else if (do_gdb_index && (streq (name, ".gdb_index")
6223                                 || streq (name, ".debug_names")))
6224         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6225       /* Trace sections for Itanium VMS.  */
6226       else if ((do_debugging || do_trace_info || do_trace_abbrevs
6227                 || do_trace_aranges)
6228                && const_strneq (name, ".trace_"))
6229         {
6230           name += sizeof (".trace_") - 1;
6231
6232           if (do_debugging
6233               || (do_trace_info     && streq (name, "info"))
6234               || (do_trace_abbrevs  && streq (name, "abbrev"))
6235               || (do_trace_aranges  && streq (name, "aranges"))
6236               )
6237             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6238         }
6239       else if ((do_debugging || do_debug_links)
6240                && (const_strneq (name, ".gnu_debuglink")
6241                    || const_strneq (name, ".gnu_debugaltlink")))
6242         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6243     }
6244
6245   if (! do_sections)
6246     return TRUE;
6247
6248   if (filedata->file_header.e_shnum > 1)
6249     printf (_("\nSection Headers:\n"));
6250   else
6251     printf (_("\nSection Header:\n"));
6252
6253   if (is_32bit_elf)
6254     {
6255       if (do_section_details)
6256         {
6257           printf (_("  [Nr] Name\n"));
6258           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
6259         }
6260       else
6261         printf
6262           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
6263     }
6264   else if (do_wide)
6265     {
6266       if (do_section_details)
6267         {
6268           printf (_("  [Nr] Name\n"));
6269           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
6270         }
6271       else
6272         printf
6273           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
6274     }
6275   else
6276     {
6277       if (do_section_details)
6278         {
6279           printf (_("  [Nr] Name\n"));
6280           printf (_("       Type              Address          Offset            Link\n"));
6281           printf (_("       Size              EntSize          Info              Align\n"));
6282         }
6283       else
6284         {
6285           printf (_("  [Nr] Name              Type             Address           Offset\n"));
6286           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
6287         }
6288     }
6289
6290   if (do_section_details)
6291     printf (_("       Flags\n"));
6292
6293   for (i = 0, section = filedata->section_headers;
6294        i < filedata->file_header.e_shnum;
6295        i++, section++)
6296     {
6297       /* Run some sanity checks on the section header.  */
6298
6299       /* Check the sh_link field.  */
6300       switch (section->sh_type)
6301         {
6302         case SHT_REL:
6303         case SHT_RELA:
6304           if (section->sh_link == 0
6305               && (filedata->file_header.e_type == ET_EXEC
6306                   || filedata->file_header.e_type == ET_DYN))
6307             /* A dynamic relocation section where all entries use a
6308                zero symbol index need not specify a symtab section.  */
6309             break;
6310           /* Fall through.  */
6311         case SHT_SYMTAB_SHNDX:
6312         case SHT_GROUP:
6313         case SHT_HASH:
6314         case SHT_GNU_HASH:
6315         case SHT_GNU_versym:
6316           if (section->sh_link == 0
6317               || section->sh_link >= filedata->file_header.e_shnum
6318               || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6319                   && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6320             warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6321                   i, section->sh_link);
6322           break;
6323
6324         case SHT_DYNAMIC:
6325         case SHT_SYMTAB:
6326         case SHT_DYNSYM:
6327         case SHT_GNU_verneed:
6328         case SHT_GNU_verdef:
6329         case SHT_GNU_LIBLIST:
6330           if (section->sh_link == 0
6331               || section->sh_link >= filedata->file_header.e_shnum
6332               || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6333             warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6334                   i, section->sh_link);
6335           break;
6336
6337         case SHT_INIT_ARRAY:
6338         case SHT_FINI_ARRAY:
6339         case SHT_PREINIT_ARRAY:
6340           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6341             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6342                   i, section->sh_link);
6343           break;
6344
6345         default:
6346           /* FIXME: Add support for target specific section types.  */
6347 #if 0     /* Currently we do not check other section types as there are too
6348              many special cases.  Stab sections for example have a type
6349              of SHT_PROGBITS but an sh_link field that links to the .stabstr
6350              section.  */
6351           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6352             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6353                   i, section->sh_link);
6354 #endif
6355           break;
6356         }
6357
6358       /* Check the sh_info field.  */
6359       switch (section->sh_type)
6360         {
6361         case SHT_REL:
6362         case SHT_RELA:
6363           if (section->sh_info == 0
6364               && (filedata->file_header.e_type == ET_EXEC
6365                   || filedata->file_header.e_type == ET_DYN))
6366             /* Dynamic relocations apply to segments, so they do not
6367                need to specify the section they relocate.  */
6368             break;
6369           if (section->sh_info == 0
6370               || section->sh_info >= filedata->file_header.e_shnum
6371               || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6372                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6373                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6374                   && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6375                   && filedata->section_headers[section->sh_info].sh_type != SHT_FINI_ARRAY
6376                   && filedata->section_headers[section->sh_info].sh_type != SHT_PREINIT_ARRAY
6377                   /* FIXME: Are other section types valid ?  */
6378                   && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6379             warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6380                   i, section->sh_info);
6381           break;
6382
6383         case SHT_DYNAMIC:
6384         case SHT_HASH:
6385         case SHT_SYMTAB_SHNDX:
6386         case SHT_INIT_ARRAY:
6387         case SHT_FINI_ARRAY:
6388         case SHT_PREINIT_ARRAY:
6389           if (section->sh_info != 0)
6390             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6391                   i, section->sh_info);
6392           break;
6393
6394         case SHT_GROUP:
6395         case SHT_SYMTAB:
6396         case SHT_DYNSYM:
6397           /* A symbol index - we assume that it is valid.  */
6398           break;
6399
6400         default:
6401           /* FIXME: Add support for target specific section types.  */
6402           if (section->sh_type == SHT_NOBITS)
6403             /* NOBITS section headers with non-zero sh_info fields can be
6404                created when a binary is stripped of everything but its debug
6405                information.  The stripped sections have their headers
6406                preserved but their types set to SHT_NOBITS.  So do not check
6407                this type of section.  */
6408             ;
6409           else if (section->sh_flags & SHF_INFO_LINK)
6410             {
6411               if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6412                 warn (_("[%2u]: Expected link to another section in info field"), i);
6413             }
6414           else if (section->sh_type < SHT_LOOS
6415                    && (section->sh_flags & SHF_GNU_MBIND) == 0
6416                    && section->sh_info != 0)
6417             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6418                   i, section->sh_info);
6419           break;
6420         }
6421
6422       /* Check the sh_size field.  */
6423       if (section->sh_size > filedata->file_size
6424           && section->sh_type != SHT_NOBITS
6425           && section->sh_type != SHT_NULL
6426           && section->sh_type < SHT_LOOS)
6427         warn (_("Size of section %u is larger than the entire file!\n"), i);
6428
6429       printf ("  [%2u] ", i);
6430       if (do_section_details)
6431         printf ("%s\n      ", printable_section_name (filedata, section));
6432       else
6433         print_symbol (-17, SECTION_NAME (section));
6434
6435       printf (do_wide ? " %-15s " : " %-15.15s ",
6436               get_section_type_name (filedata, section->sh_type));
6437
6438       if (is_32bit_elf)
6439         {
6440           const char * link_too_big = NULL;
6441
6442           print_vma (section->sh_addr, LONG_HEX);
6443
6444           printf ( " %6.6lx %6.6lx %2.2lx",
6445                    (unsigned long) section->sh_offset,
6446                    (unsigned long) section->sh_size,
6447                    (unsigned long) section->sh_entsize);
6448
6449           if (do_section_details)
6450             fputs ("  ", stdout);
6451           else
6452             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6453
6454           if (section->sh_link >= filedata->file_header.e_shnum)
6455             {
6456               link_too_big = "";
6457               /* The sh_link value is out of range.  Normally this indicates
6458                  an error but it can have special values in Solaris binaries.  */
6459               switch (filedata->file_header.e_machine)
6460                 {
6461                 case EM_386:
6462                 case EM_IAMCU:
6463                 case EM_X86_64:
6464                 case EM_L1OM:
6465                 case EM_K1OM:
6466                 case EM_OLD_SPARCV9:
6467                 case EM_SPARC32PLUS:
6468                 case EM_SPARCV9:
6469                 case EM_SPARC:
6470                   if (section->sh_link == (SHN_BEFORE & 0xffff))
6471                     link_too_big = "BEFORE";
6472                   else if (section->sh_link == (SHN_AFTER & 0xffff))
6473                     link_too_big = "AFTER";
6474                   break;
6475                 default:
6476                   break;
6477                 }
6478             }
6479
6480           if (do_section_details)
6481             {
6482               if (link_too_big != NULL && * link_too_big)
6483                 printf ("<%s> ", link_too_big);
6484               else
6485                 printf ("%2u ", section->sh_link);
6486               printf ("%3u %2lu\n", section->sh_info,
6487                       (unsigned long) section->sh_addralign);
6488             }
6489           else
6490             printf ("%2u %3u %2lu\n",
6491                     section->sh_link,
6492                     section->sh_info,
6493                     (unsigned long) section->sh_addralign);
6494
6495           if (link_too_big && ! * link_too_big)
6496             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6497                   i, section->sh_link);
6498         }
6499       else if (do_wide)
6500         {
6501           print_vma (section->sh_addr, LONG_HEX);
6502
6503           if ((long) section->sh_offset == section->sh_offset)
6504             printf (" %6.6lx", (unsigned long) section->sh_offset);
6505           else
6506             {
6507               putchar (' ');
6508               print_vma (section->sh_offset, LONG_HEX);
6509             }
6510
6511           if ((unsigned long) section->sh_size == section->sh_size)
6512             printf (" %6.6lx", (unsigned long) section->sh_size);
6513           else
6514             {
6515               putchar (' ');
6516               print_vma (section->sh_size, LONG_HEX);
6517             }
6518
6519           if ((unsigned long) section->sh_entsize == section->sh_entsize)
6520             printf (" %2.2lx", (unsigned long) section->sh_entsize);
6521           else
6522             {
6523               putchar (' ');
6524               print_vma (section->sh_entsize, LONG_HEX);
6525             }
6526
6527           if (do_section_details)
6528             fputs ("  ", stdout);
6529           else
6530             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6531
6532           printf ("%2u %3u ", section->sh_link, section->sh_info);
6533
6534           if ((unsigned long) section->sh_addralign == section->sh_addralign)
6535             printf ("%2lu\n", (unsigned long) section->sh_addralign);
6536           else
6537             {
6538               print_vma (section->sh_addralign, DEC);
6539               putchar ('\n');
6540             }
6541         }
6542       else if (do_section_details)
6543         {
6544           putchar (' ');
6545           print_vma (section->sh_addr, LONG_HEX);
6546           if ((long) section->sh_offset == section->sh_offset)
6547             printf ("  %16.16lx", (unsigned long) section->sh_offset);
6548           else
6549             {
6550               printf ("  ");
6551               print_vma (section->sh_offset, LONG_HEX);
6552             }
6553           printf ("  %u\n       ", section->sh_link);
6554           print_vma (section->sh_size, LONG_HEX);
6555           putchar (' ');
6556           print_vma (section->sh_entsize, LONG_HEX);
6557
6558           printf ("  %-16u  %lu\n",
6559                   section->sh_info,
6560                   (unsigned long) section->sh_addralign);
6561         }
6562       else
6563         {
6564           putchar (' ');
6565           print_vma (section->sh_addr, LONG_HEX);
6566           if ((long) section->sh_offset == section->sh_offset)
6567             printf ("  %8.8lx", (unsigned long) section->sh_offset);
6568           else
6569             {
6570               printf ("  ");
6571               print_vma (section->sh_offset, LONG_HEX);
6572             }
6573           printf ("\n       ");
6574           print_vma (section->sh_size, LONG_HEX);
6575           printf ("  ");
6576           print_vma (section->sh_entsize, LONG_HEX);
6577
6578           printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6579
6580           printf ("     %2u   %3u     %lu\n",
6581                   section->sh_link,
6582                   section->sh_info,
6583                   (unsigned long) section->sh_addralign);
6584         }
6585
6586       if (do_section_details)
6587         {
6588           printf ("       %s\n", get_elf_section_flags (filedata, section->sh_flags));
6589           if ((section->sh_flags & SHF_COMPRESSED) != 0)
6590             {
6591               /* Minimum section size is 12 bytes for 32-bit compression
6592                  header + 12 bytes for compressed data header.  */
6593               unsigned char buf[24];
6594
6595               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6596               if (get_data (&buf, filedata, section->sh_offset, 1,
6597                             sizeof (buf), _("compression header")))
6598                 {
6599                   Elf_Internal_Chdr chdr;
6600
6601                   (void) get_compression_header (&chdr, buf, sizeof (buf));
6602
6603                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6604                     printf ("       ZLIB, ");
6605                   else
6606                     printf (_("       [<unknown>: 0x%x], "),
6607                             chdr.ch_type);
6608                   print_vma (chdr.ch_size, LONG_HEX);
6609                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6610                 }
6611             }
6612         }
6613     }
6614
6615   if (!do_section_details)
6616     {
6617       /* The ordering of the letters shown here matches the ordering of the
6618          corresponding SHF_xxx values, and hence the order in which these
6619          letters will be displayed to the user.  */
6620       printf (_("Key to Flags:\n\
6621   W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6622   L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6623   C (compressed), x (unknown), o (OS specific), E (exclude),\n  "));
6624       if (filedata->file_header.e_machine == EM_X86_64
6625           || filedata->file_header.e_machine == EM_L1OM
6626           || filedata->file_header.e_machine == EM_K1OM)
6627         printf (_("l (large), "));
6628       else if (filedata->file_header.e_machine == EM_ARM)
6629         printf (_("y (purecode), "));
6630       else if (filedata->file_header.e_machine == EM_PPC)
6631         printf (_("v (VLE), "));
6632       printf ("p (processor specific)\n");
6633     }
6634
6635   return TRUE;
6636 }
6637
6638 static const char *
6639 get_group_flags (unsigned int flags)
6640 {
6641   static char buff[128];
6642
6643   if (flags == 0)
6644     return "";
6645   else if (flags == GRP_COMDAT)
6646     return "COMDAT ";
6647
6648   snprintf (buff, 14, _("[0x%x: "), flags);
6649
6650   flags &= ~ GRP_COMDAT;
6651   if (flags & GRP_MASKOS)
6652     {
6653       strcat (buff, "<OS specific>");
6654       flags &= ~ GRP_MASKOS;
6655     }
6656
6657   if (flags & GRP_MASKPROC)
6658     {
6659       strcat (buff, "<PROC specific>");
6660       flags &= ~ GRP_MASKPROC;
6661     }
6662
6663   if (flags)
6664     strcat (buff, "<unknown>");
6665
6666   strcat (buff, "]");
6667   return buff;
6668 }
6669
6670 static bfd_boolean
6671 process_section_groups (Filedata * filedata)
6672 {
6673   Elf_Internal_Shdr * section;
6674   unsigned int i;
6675   struct group * group;
6676   Elf_Internal_Shdr * symtab_sec;
6677   Elf_Internal_Shdr * strtab_sec;
6678   Elf_Internal_Sym * symtab;
6679   unsigned long num_syms;
6680   char * strtab;
6681   size_t strtab_size;
6682
6683   /* Don't process section groups unless needed.  */
6684   if (!do_unwind && !do_section_groups)
6685     return TRUE;
6686
6687   if (filedata->file_header.e_shnum == 0)
6688     {
6689       if (do_section_groups)
6690         printf (_("\nThere are no sections to group in this file.\n"));
6691
6692       return TRUE;
6693     }
6694
6695   if (filedata->section_headers == NULL)
6696     {
6697       error (_("Section headers are not available!\n"));
6698       /* PR 13622: This can happen with a corrupt ELF header.  */
6699       return FALSE;
6700     }
6701
6702   section_headers_groups = (struct group **) calloc (filedata->file_header.e_shnum,
6703                                                      sizeof (struct group *));
6704
6705   if (section_headers_groups == NULL)
6706     {
6707       error (_("Out of memory reading %u section group headers\n"),
6708              filedata->file_header.e_shnum);
6709       return FALSE;
6710     }
6711
6712   /* Scan the sections for the group section.  */
6713   group_count = 0;
6714   for (i = 0, section = filedata->section_headers;
6715        i < filedata->file_header.e_shnum;
6716        i++, section++)
6717     if (section->sh_type == SHT_GROUP)
6718       group_count++;
6719
6720   if (group_count == 0)
6721     {
6722       if (do_section_groups)
6723         printf (_("\nThere are no section groups in this file.\n"));
6724
6725       return TRUE;
6726     }
6727
6728   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6729
6730   if (section_groups == NULL)
6731     {
6732       error (_("Out of memory reading %lu groups\n"),
6733              (unsigned long) group_count);
6734       return FALSE;
6735     }
6736
6737   symtab_sec = NULL;
6738   strtab_sec = NULL;
6739   symtab = NULL;
6740   num_syms = 0;
6741   strtab = NULL;
6742   strtab_size = 0;
6743   for (i = 0, section = filedata->section_headers, group = section_groups;
6744        i < filedata->file_header.e_shnum;
6745        i++, section++)
6746     {
6747       if (section->sh_type == SHT_GROUP)
6748         {
6749           const char * name = printable_section_name (filedata, section);
6750           const char * group_name;
6751           unsigned char * start;
6752           unsigned char * indices;
6753           unsigned int entry, j, size;
6754           Elf_Internal_Shdr * sec;
6755           Elf_Internal_Sym * sym;
6756
6757           /* Get the symbol table.  */
6758           if (section->sh_link >= filedata->file_header.e_shnum
6759               || ((sec = filedata->section_headers + section->sh_link)->sh_type
6760                   != SHT_SYMTAB))
6761             {
6762               error (_("Bad sh_link in group section `%s'\n"), name);
6763               continue;
6764             }
6765
6766           if (symtab_sec != sec)
6767             {
6768               symtab_sec = sec;
6769               if (symtab)
6770                 free (symtab);
6771               symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
6772             }
6773
6774           if (symtab == NULL)
6775             {
6776               error (_("Corrupt header in group section `%s'\n"), name);
6777               continue;
6778             }
6779
6780           if (section->sh_info >= num_syms)
6781             {
6782               error (_("Bad sh_info in group section `%s'\n"), name);
6783               continue;
6784             }
6785
6786           sym = symtab + section->sh_info;
6787
6788           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6789             {
6790               if (sym->st_shndx == 0
6791                   || sym->st_shndx >= filedata->file_header.e_shnum)
6792                 {
6793                   error (_("Bad sh_info in group section `%s'\n"), name);
6794                   continue;
6795                 }
6796
6797               group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
6798               strtab_sec = NULL;
6799               if (strtab)
6800                 free (strtab);
6801               strtab = NULL;
6802               strtab_size = 0;
6803             }
6804           else
6805             {
6806               /* Get the string table.  */
6807               if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
6808                 {
6809                   strtab_sec = NULL;
6810                   if (strtab)
6811                     free (strtab);
6812                   strtab = NULL;
6813                   strtab_size = 0;
6814                 }
6815               else if (strtab_sec
6816                        != (sec = filedata->section_headers + symtab_sec->sh_link))
6817                 {
6818                   strtab_sec = sec;
6819                   if (strtab)
6820                     free (strtab);
6821
6822                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
6823                                               1, strtab_sec->sh_size,
6824                                               _("string table"));
6825                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6826                 }
6827               group_name = sym->st_name < strtab_size
6828                 ? strtab + sym->st_name : _("<corrupt>");
6829             }
6830
6831           /* PR 17531: file: loop.  */
6832           if (section->sh_entsize > section->sh_size)
6833             {
6834               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6835                      printable_section_name (filedata, section),
6836                      (unsigned long) section->sh_entsize,
6837                      (unsigned long) section->sh_size);
6838               break;
6839             }
6840
6841           start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
6842                                               1, section->sh_size,
6843                                               _("section data"));
6844           if (start == NULL)
6845             continue;
6846
6847           indices = start;
6848           size = (section->sh_size / section->sh_entsize) - 1;
6849           entry = byte_get (indices, 4);
6850           indices += 4;
6851
6852           if (do_section_groups)
6853             {
6854               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6855                       get_group_flags (entry), i, name, group_name, size);
6856
6857               printf (_("   [Index]    Name\n"));
6858             }
6859
6860           group->group_index = i;
6861
6862           for (j = 0; j < size; j++)
6863             {
6864               struct group_list * g;
6865
6866               entry = byte_get (indices, 4);
6867               indices += 4;
6868
6869               if (entry >= filedata->file_header.e_shnum)
6870                 {
6871                   static unsigned num_group_errors = 0;
6872
6873                   if (num_group_errors ++ < 10)
6874                     {
6875                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6876                              entry, i, filedata->file_header.e_shnum - 1);
6877                       if (num_group_errors == 10)
6878                         warn (_("Further error messages about overlarge group section indices suppressed\n"));
6879                     }
6880                   continue;
6881                 }
6882
6883               if (section_headers_groups [entry] != NULL)
6884                 {
6885                   if (entry)
6886                     {
6887                       static unsigned num_errs = 0;
6888
6889                       if (num_errs ++ < 10)
6890                         {
6891                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6892                                  entry, i,
6893                                  section_headers_groups [entry]->group_index);
6894                           if (num_errs == 10)
6895                             warn (_("Further error messages about already contained group sections suppressed\n"));
6896                         }
6897                       continue;
6898                     }
6899                   else
6900                     {
6901                       /* Intel C/C++ compiler may put section 0 in a
6902                          section group.  We just warn it the first time
6903                          and ignore it afterwards.  */
6904                       static bfd_boolean warned = FALSE;
6905                       if (!warned)
6906                         {
6907                           error (_("section 0 in group section [%5u]\n"),
6908                                  section_headers_groups [entry]->group_index);
6909                           warned = TRUE;
6910                         }
6911                     }
6912                 }
6913
6914               section_headers_groups [entry] = group;
6915
6916               if (do_section_groups)
6917                 {
6918                   sec = filedata->section_headers + entry;
6919                   printf ("   [%5u]   %s\n", entry, printable_section_name (filedata, sec));
6920                 }
6921
6922               g = (struct group_list *) xmalloc (sizeof (struct group_list));
6923               g->section_index = entry;
6924               g->next = group->root;
6925               group->root = g;
6926             }
6927
6928           if (start)
6929             free (start);
6930
6931           group++;
6932         }
6933     }
6934
6935   if (symtab)
6936     free (symtab);
6937   if (strtab)
6938     free (strtab);
6939   return TRUE;
6940 }
6941
6942 /* Data used to display dynamic fixups.  */
6943
6944 struct ia64_vms_dynfixup
6945 {
6946   bfd_vma needed_ident;         /* Library ident number.  */
6947   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
6948   bfd_vma fixup_needed;         /* Index of the library.  */
6949   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
6950   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
6951 };
6952
6953 /* Data used to display dynamic relocations.  */
6954
6955 struct ia64_vms_dynimgrela
6956 {
6957   bfd_vma img_rela_cnt;         /* Number of relocations.  */
6958   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
6959 };
6960
6961 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6962    library).  */
6963
6964 static bfd_boolean
6965 dump_ia64_vms_dynamic_fixups (Filedata *                  filedata,
6966                               struct ia64_vms_dynfixup *  fixup,
6967                               const char *                strtab,
6968                               unsigned int                strtab_sz)
6969 {
6970   Elf64_External_VMS_IMAGE_FIXUP * imfs;
6971   long i;
6972   const char * lib_name;
6973
6974   imfs = get_data (NULL, filedata, dynamic_addr + fixup->fixup_rela_off,
6975                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
6976                    _("dynamic section image fixups"));
6977   if (!imfs)
6978     return FALSE;
6979
6980   if (fixup->needed < strtab_sz)
6981     lib_name = strtab + fixup->needed;
6982   else
6983     {
6984       warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6985             (unsigned long) fixup->needed);
6986       lib_name = "???";
6987     }
6988   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6989           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6990   printf
6991     (_("Seg Offset           Type                             SymVec DataType\n"));
6992
6993   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6994     {
6995       unsigned int type;
6996       const char *rtype;
6997
6998       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6999       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
7000       type = BYTE_GET (imfs [i].type);
7001       rtype = elf_ia64_reloc_type (type);
7002       if (rtype == NULL)
7003         printf (" 0x%08x                       ", type);
7004       else
7005         printf (" %-32s ", rtype);
7006       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
7007       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
7008     }
7009
7010   free (imfs);
7011   return TRUE;
7012 }
7013
7014 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
7015
7016 static bfd_boolean
7017 dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
7018 {
7019   Elf64_External_VMS_IMAGE_RELA *imrs;
7020   long i;
7021
7022   imrs = get_data (NULL, filedata, dynamic_addr + imgrela->img_rela_off,
7023                    1, imgrela->img_rela_cnt * sizeof (*imrs),
7024                    _("dynamic section image relocations"));
7025   if (!imrs)
7026     return FALSE;
7027
7028   printf (_("\nImage relocs\n"));
7029   printf
7030     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
7031
7032   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
7033     {
7034       unsigned int type;
7035       const char *rtype;
7036
7037       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
7038       printf ("%08" BFD_VMA_FMT "x ",
7039               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
7040       type = BYTE_GET (imrs [i].type);
7041       rtype = elf_ia64_reloc_type (type);
7042       if (rtype == NULL)
7043         printf ("0x%08x                      ", type);
7044       else
7045         printf ("%-31s ", rtype);
7046       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
7047       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
7048       printf ("%08" BFD_VMA_FMT "x\n",
7049               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
7050     }
7051
7052   free (imrs);
7053   return TRUE;
7054 }
7055
7056 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
7057
7058 static bfd_boolean
7059 process_ia64_vms_dynamic_relocs (Filedata * filedata)
7060 {
7061   struct ia64_vms_dynfixup fixup;
7062   struct ia64_vms_dynimgrela imgrela;
7063   Elf_Internal_Dyn *entry;
7064   bfd_vma strtab_off = 0;
7065   bfd_vma strtab_sz = 0;
7066   char *strtab = NULL;
7067   bfd_boolean res = TRUE;
7068
7069   memset (&fixup, 0, sizeof (fixup));
7070   memset (&imgrela, 0, sizeof (imgrela));
7071
7072   /* Note: the order of the entries is specified by the OpenVMS specs.  */
7073   for (entry = dynamic_section;
7074        entry < dynamic_section + dynamic_nent;
7075        entry++)
7076     {
7077       switch (entry->d_tag)
7078         {
7079         case DT_IA_64_VMS_STRTAB_OFFSET:
7080           strtab_off = entry->d_un.d_val;
7081           break;
7082         case DT_STRSZ:
7083           strtab_sz = entry->d_un.d_val;
7084           if (strtab == NULL)
7085             strtab = get_data (NULL, filedata, dynamic_addr + strtab_off,
7086                                1, strtab_sz, _("dynamic string section"));
7087           break;
7088
7089         case DT_IA_64_VMS_NEEDED_IDENT:
7090           fixup.needed_ident = entry->d_un.d_val;
7091           break;
7092         case DT_NEEDED:
7093           fixup.needed = entry->d_un.d_val;
7094           break;
7095         case DT_IA_64_VMS_FIXUP_NEEDED:
7096           fixup.fixup_needed = entry->d_un.d_val;
7097           break;
7098         case DT_IA_64_VMS_FIXUP_RELA_CNT:
7099           fixup.fixup_rela_cnt = entry->d_un.d_val;
7100           break;
7101         case DT_IA_64_VMS_FIXUP_RELA_OFF:
7102           fixup.fixup_rela_off = entry->d_un.d_val;
7103           if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7104             res = FALSE;
7105           break;
7106         case DT_IA_64_VMS_IMG_RELA_CNT:
7107           imgrela.img_rela_cnt = entry->d_un.d_val;
7108           break;
7109         case DT_IA_64_VMS_IMG_RELA_OFF:
7110           imgrela.img_rela_off = entry->d_un.d_val;
7111           if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7112             res = FALSE;
7113           break;
7114
7115         default:
7116           break;
7117         }
7118     }
7119
7120   if (strtab != NULL)
7121     free (strtab);
7122
7123   return res;
7124 }
7125
7126 static struct
7127 {
7128   const char * name;
7129   int reloc;
7130   int size;
7131   int rela;
7132 }
7133   dynamic_relocations [] =
7134 {
7135   { "REL", DT_REL, DT_RELSZ, FALSE },
7136   { "RELA", DT_RELA, DT_RELASZ, TRUE },
7137   { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7138 };
7139
7140 /* Process the reloc section.  */
7141
7142 static bfd_boolean
7143 process_relocs (Filedata * filedata)
7144 {
7145   unsigned long rel_size;
7146   unsigned long rel_offset;
7147
7148   if (!do_reloc)
7149     return TRUE;
7150
7151   if (do_using_dynamic)
7152     {
7153       int          is_rela;
7154       const char * name;
7155       bfd_boolean  has_dynamic_reloc;
7156       unsigned int i;
7157
7158       has_dynamic_reloc = FALSE;
7159
7160       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7161         {
7162           is_rela = dynamic_relocations [i].rela;
7163           name = dynamic_relocations [i].name;
7164           rel_size = dynamic_info [dynamic_relocations [i].size];
7165           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7166
7167           if (rel_size)
7168             has_dynamic_reloc = TRUE;
7169
7170           if (is_rela == UNKNOWN)
7171             {
7172               if (dynamic_relocations [i].reloc == DT_JMPREL)
7173                 switch (dynamic_info[DT_PLTREL])
7174                   {
7175                   case DT_REL:
7176                     is_rela = FALSE;
7177                     break;
7178                   case DT_RELA:
7179                     is_rela = TRUE;
7180                     break;
7181                   }
7182             }
7183
7184           if (rel_size)
7185             {
7186               printf
7187                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7188                  name, rel_offset, rel_size);
7189
7190               dump_relocations (filedata,
7191                                 offset_from_vma (filedata, rel_offset, rel_size),
7192                                 rel_size,
7193                                 dynamic_symbols, num_dynamic_syms,
7194                                 dynamic_strings, dynamic_strings_length,
7195                                 is_rela, TRUE /* is_dynamic */);
7196             }
7197         }
7198
7199       if (is_ia64_vms (filedata))
7200         if (process_ia64_vms_dynamic_relocs (filedata))
7201           has_dynamic_reloc = TRUE;
7202
7203       if (! has_dynamic_reloc)
7204         printf (_("\nThere are no dynamic relocations in this file.\n"));
7205     }
7206   else
7207     {
7208       Elf_Internal_Shdr * section;
7209       unsigned long i;
7210       bfd_boolean found = FALSE;
7211
7212       for (i = 0, section = filedata->section_headers;
7213            i < filedata->file_header.e_shnum;
7214            i++, section++)
7215         {
7216           if (   section->sh_type != SHT_RELA
7217               && section->sh_type != SHT_REL)
7218             continue;
7219
7220           rel_offset = section->sh_offset;
7221           rel_size   = section->sh_size;
7222
7223           if (rel_size)
7224             {
7225               Elf_Internal_Shdr * strsec;
7226               int is_rela;
7227               unsigned long num_rela;
7228
7229               printf (_("\nRelocation section "));
7230
7231               if (filedata->string_table == NULL)
7232                 printf ("%d", section->sh_name);
7233               else
7234                 printf ("'%s'", printable_section_name (filedata, section));
7235
7236               num_rela = rel_size / section->sh_entsize;
7237               printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7238                                 " at offset 0x%lx contains %lu entries:\n",
7239                                 num_rela),
7240                       rel_offset, num_rela);
7241
7242               is_rela = section->sh_type == SHT_RELA;
7243
7244               if (section->sh_link != 0
7245                   && section->sh_link < filedata->file_header.e_shnum)
7246                 {
7247                   Elf_Internal_Shdr * symsec;
7248                   Elf_Internal_Sym *  symtab;
7249                   unsigned long nsyms;
7250                   unsigned long strtablen = 0;
7251                   char * strtab = NULL;
7252
7253                   symsec = filedata->section_headers + section->sh_link;
7254                   if (symsec->sh_type != SHT_SYMTAB
7255                       && symsec->sh_type != SHT_DYNSYM)
7256                     continue;
7257
7258                   symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
7259
7260                   if (symtab == NULL)
7261                     continue;
7262
7263                   if (symsec->sh_link != 0
7264                       && symsec->sh_link < filedata->file_header.e_shnum)
7265                     {
7266                       strsec = filedata->section_headers + symsec->sh_link;
7267
7268                       strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7269                                                   1, strsec->sh_size,
7270                                                   _("string table"));
7271                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
7272                     }
7273
7274                   dump_relocations (filedata, rel_offset, rel_size,
7275                                     symtab, nsyms, strtab, strtablen,
7276                                     is_rela,
7277                                     symsec->sh_type == SHT_DYNSYM);
7278                   if (strtab)
7279                     free (strtab);
7280                   free (symtab);
7281                 }
7282               else
7283                 dump_relocations (filedata, rel_offset, rel_size,
7284                                   NULL, 0, NULL, 0, is_rela,
7285                                   FALSE /* is_dynamic */);
7286
7287               found = TRUE;
7288             }
7289         }
7290
7291       if (! found)
7292         {
7293           /* Users sometimes forget the -D option, so try to be helpful.  */
7294           for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7295             {
7296               if (dynamic_info [dynamic_relocations [i].size])
7297                 {
7298                   printf (_("\nThere are no static relocations in this file."));
7299                   printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7300
7301                   break;
7302                 }
7303             }
7304           if (i == ARRAY_SIZE (dynamic_relocations))
7305             printf (_("\nThere are no relocations in this file.\n"));
7306         }
7307     }
7308
7309   return TRUE;
7310 }
7311
7312 /* An absolute address consists of a section and an offset.  If the
7313    section is NULL, the offset itself is the address, otherwise, the
7314    address equals to LOAD_ADDRESS(section) + offset.  */
7315
7316 struct absaddr
7317 {
7318   unsigned short section;
7319   bfd_vma offset;
7320 };
7321
7322 #define ABSADDR(a) \
7323   ((a).section \
7324    ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7325    : (a).offset)
7326
7327 /* Find the nearest symbol at or below ADDR.  Returns the symbol
7328    name, if found, and the offset from the symbol to ADDR.  */
7329
7330 static void
7331 find_symbol_for_address (Filedata *          filedata,
7332                          Elf_Internal_Sym *  symtab,
7333                          unsigned long       nsyms,
7334                          const char *        strtab,
7335                          unsigned long       strtab_size,
7336                          struct absaddr      addr,
7337                          const char **       symname,
7338                          bfd_vma *           offset)
7339 {
7340   bfd_vma dist = 0x100000;
7341   Elf_Internal_Sym * sym;
7342   Elf_Internal_Sym * beg;
7343   Elf_Internal_Sym * end;
7344   Elf_Internal_Sym * best = NULL;
7345
7346   REMOVE_ARCH_BITS (addr.offset);
7347   beg = symtab;
7348   end = symtab + nsyms;
7349
7350   while (beg < end)
7351     {
7352       bfd_vma value;
7353
7354       sym = beg + (end - beg) / 2;
7355
7356       value = sym->st_value;
7357       REMOVE_ARCH_BITS (value);
7358
7359       if (sym->st_name != 0
7360           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7361           && addr.offset >= value
7362           && addr.offset - value < dist)
7363         {
7364           best = sym;
7365           dist = addr.offset - value;
7366           if (!dist)
7367             break;
7368         }
7369
7370       if (addr.offset < value)
7371         end = sym;
7372       else
7373         beg = sym + 1;
7374     }
7375
7376   if (best)
7377     {
7378       *symname = (best->st_name >= strtab_size
7379                   ? _("<corrupt>") : strtab + best->st_name);
7380       *offset = dist;
7381       return;
7382     }
7383
7384   *symname = NULL;
7385   *offset = addr.offset;
7386 }
7387
7388 static /* signed */ int
7389 symcmp (const void *p, const void *q)
7390 {
7391   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7392   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7393
7394   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7395 }
7396
7397 /* Process the unwind section.  */
7398
7399 #include "unwind-ia64.h"
7400
7401 struct ia64_unw_table_entry
7402 {
7403   struct absaddr start;
7404   struct absaddr end;
7405   struct absaddr info;
7406 };
7407
7408 struct ia64_unw_aux_info
7409 {
7410   struct ia64_unw_table_entry * table;          /* Unwind table.  */
7411   unsigned long                 table_len;      /* Length of unwind table.  */
7412   unsigned char *               info;           /* Unwind info.  */
7413   unsigned long                 info_size;      /* Size of unwind info.  */
7414   bfd_vma                       info_addr;      /* Starting address of unwind info.  */
7415   bfd_vma                       seg_base;       /* Starting address of segment.  */
7416   Elf_Internal_Sym *            symtab;         /* The symbol table.  */
7417   unsigned long                 nsyms;          /* Number of symbols.  */
7418   Elf_Internal_Sym *            funtab;         /* Sorted table of STT_FUNC symbols.  */
7419   unsigned long                 nfuns;          /* Number of entries in funtab.  */
7420   char *                        strtab;         /* The string table.  */
7421   unsigned long                 strtab_size;    /* Size of string table.  */
7422 };
7423
7424 static bfd_boolean
7425 dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7426 {
7427   struct ia64_unw_table_entry * tp;
7428   unsigned long j, nfuns;
7429   int in_body;
7430   bfd_boolean res = TRUE;
7431
7432   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7433   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7434     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7435       aux->funtab[nfuns++] = aux->symtab[j];
7436   aux->nfuns = nfuns;
7437   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7438
7439   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7440     {
7441       bfd_vma stamp;
7442       bfd_vma offset;
7443       const unsigned char * dp;
7444       const unsigned char * head;
7445       const unsigned char * end;
7446       const char * procname;
7447
7448       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7449                                aux->strtab_size, tp->start, &procname, &offset);
7450
7451       fputs ("\n<", stdout);
7452
7453       if (procname)
7454         {
7455           fputs (procname, stdout);
7456
7457           if (offset)
7458             printf ("+%lx", (unsigned long) offset);
7459         }
7460
7461       fputs (">: [", stdout);
7462       print_vma (tp->start.offset, PREFIX_HEX);
7463       fputc ('-', stdout);
7464       print_vma (tp->end.offset, PREFIX_HEX);
7465       printf ("], info at +0x%lx\n",
7466               (unsigned long) (tp->info.offset - aux->seg_base));
7467
7468       /* PR 17531: file: 86232b32.  */
7469       if (aux->info == NULL)
7470         continue;
7471
7472       /* PR 17531: file: 0997b4d1.  */
7473       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7474         {
7475           warn (_("Invalid offset %lx in table entry %ld\n"),
7476                 (long) tp->info.offset, (long) (tp - aux->table));
7477           res = FALSE;
7478           continue;
7479         }
7480
7481       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7482       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7483
7484       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7485               (unsigned) UNW_VER (stamp),
7486               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7487               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7488               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7489               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7490
7491       if (UNW_VER (stamp) != 1)
7492         {
7493           printf (_("\tUnknown version.\n"));
7494           continue;
7495         }
7496
7497       in_body = 0;
7498       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7499       /* PR 17531: file: 16ceda89.  */
7500       if (end > aux->info + aux->info_size)
7501         end = aux->info + aux->info_size;
7502       for (dp = head + 8; dp < end;)
7503         dp = unw_decode (dp, in_body, & in_body, end);
7504     }
7505
7506   free (aux->funtab);
7507
7508   return res;
7509 }
7510
7511 static bfd_boolean
7512 slurp_ia64_unwind_table (Filedata *                  filedata,
7513                          struct ia64_unw_aux_info *  aux,
7514                          Elf_Internal_Shdr *         sec)
7515 {
7516   unsigned long size, nrelas, i;
7517   Elf_Internal_Phdr * seg;
7518   struct ia64_unw_table_entry * tep;
7519   Elf_Internal_Shdr * relsec;
7520   Elf_Internal_Rela * rela;
7521   Elf_Internal_Rela * rp;
7522   unsigned char * table;
7523   unsigned char * tp;
7524   Elf_Internal_Sym * sym;
7525   const char * relname;
7526
7527   aux->table_len = 0;
7528
7529   /* First, find the starting address of the segment that includes
7530      this section: */
7531
7532   if (filedata->file_header.e_phnum)
7533     {
7534       if (! get_program_headers (filedata))
7535           return FALSE;
7536
7537       for (seg = filedata->program_headers;
7538            seg < filedata->program_headers + filedata->file_header.e_phnum;
7539            ++seg)
7540         {
7541           if (seg->p_type != PT_LOAD)
7542             continue;
7543
7544           if (sec->sh_addr >= seg->p_vaddr
7545               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7546             {
7547               aux->seg_base = seg->p_vaddr;
7548               break;
7549             }
7550         }
7551     }
7552
7553   /* Second, build the unwind table from the contents of the unwind section:  */
7554   size = sec->sh_size;
7555   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7556                                       _("unwind table"));
7557   if (!table)
7558     return FALSE;
7559
7560   aux->table_len = size / (3 * eh_addr_size);
7561   aux->table = (struct ia64_unw_table_entry *)
7562     xcmalloc (aux->table_len, sizeof (aux->table[0]));
7563   tep = aux->table;
7564
7565   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7566     {
7567       tep->start.section = SHN_UNDEF;
7568       tep->end.section   = SHN_UNDEF;
7569       tep->info.section  = SHN_UNDEF;
7570       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7571       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7572       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7573       tep->start.offset += aux->seg_base;
7574       tep->end.offset   += aux->seg_base;
7575       tep->info.offset  += aux->seg_base;
7576     }
7577   free (table);
7578
7579   /* Third, apply any relocations to the unwind table:  */
7580   for (relsec = filedata->section_headers;
7581        relsec < filedata->section_headers + filedata->file_header.e_shnum;
7582        ++relsec)
7583     {
7584       if (relsec->sh_type != SHT_RELA
7585           || relsec->sh_info >= filedata->file_header.e_shnum
7586           || filedata->section_headers + relsec->sh_info != sec)
7587         continue;
7588
7589       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7590                               & rela, & nrelas))
7591         {
7592           free (aux->table);
7593           aux->table = NULL;
7594           aux->table_len = 0;
7595           return FALSE;
7596         }
7597
7598       for (rp = rela; rp < rela + nrelas; ++rp)
7599         {
7600           unsigned int sym_ndx;
7601           unsigned int r_type = get_reloc_type (filedata, rp->r_info);
7602           relname = elf_ia64_reloc_type (r_type);
7603
7604           /* PR 17531: file: 9fa67536.  */
7605           if (relname == NULL)
7606             {
7607               warn (_("Skipping unknown relocation type: %u\n"), r_type);
7608               continue;
7609             }
7610
7611           if (! const_strneq (relname, "R_IA64_SEGREL"))
7612             {
7613               warn (_("Skipping unexpected relocation type: %s\n"), relname);
7614               continue;
7615             }
7616
7617           i = rp->r_offset / (3 * eh_addr_size);
7618
7619           /* PR 17531: file: 5bc8d9bf.  */
7620           if (i >= aux->table_len)
7621             {
7622               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7623               continue;
7624             }
7625
7626           sym_ndx = get_reloc_symindex (rp->r_info);
7627           if (sym_ndx >= aux->nsyms)
7628             {
7629               warn (_("Skipping reloc with invalid symbol index: %u\n"),
7630                     sym_ndx);
7631               continue;
7632             }
7633           sym = aux->symtab + sym_ndx;
7634
7635           switch (rp->r_offset / eh_addr_size % 3)
7636             {
7637             case 0:
7638               aux->table[i].start.section = sym->st_shndx;
7639               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
7640               break;
7641             case 1:
7642               aux->table[i].end.section   = sym->st_shndx;
7643               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
7644               break;
7645             case 2:
7646               aux->table[i].info.section  = sym->st_shndx;
7647               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
7648               break;
7649             default:
7650               break;
7651             }
7652         }
7653
7654       free (rela);
7655     }
7656
7657   return TRUE;
7658 }
7659
7660 static bfd_boolean
7661 ia64_process_unwind (Filedata * filedata)
7662 {
7663   Elf_Internal_Shdr * sec;
7664   Elf_Internal_Shdr * unwsec = NULL;
7665   Elf_Internal_Shdr * strsec;
7666   unsigned long i, unwcount = 0, unwstart = 0;
7667   struct ia64_unw_aux_info aux;
7668   bfd_boolean res = TRUE;
7669
7670   memset (& aux, 0, sizeof (aux));
7671
7672   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7673     {
7674       if (sec->sh_type == SHT_SYMTAB
7675           && sec->sh_link < filedata->file_header.e_shnum)
7676         {
7677           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
7678
7679           strsec = filedata->section_headers + sec->sh_link;
7680           if (aux.strtab != NULL)
7681             {
7682               error (_("Multiple auxillary string tables encountered\n"));
7683               free (aux.strtab);
7684               res = FALSE;
7685             }
7686           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7687                                           1, strsec->sh_size,
7688                                           _("string table"));
7689           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7690         }
7691       else if (sec->sh_type == SHT_IA_64_UNWIND)
7692         unwcount++;
7693     }
7694
7695   if (!unwcount)
7696     printf (_("\nThere are no unwind sections in this file.\n"));
7697
7698   while (unwcount-- > 0)
7699     {
7700       char * suffix;
7701       size_t len, len2;
7702
7703       for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7704            i < filedata->file_header.e_shnum; ++i, ++sec)
7705         if (sec->sh_type == SHT_IA_64_UNWIND)
7706           {
7707             unwsec = sec;
7708             break;
7709           }
7710       /* We have already counted the number of SHT_IA64_UNWIND
7711          sections so the loop above should never fail.  */
7712       assert (unwsec != NULL);
7713
7714       unwstart = i + 1;
7715       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7716
7717       if ((unwsec->sh_flags & SHF_GROUP) != 0)
7718         {
7719           /* We need to find which section group it is in.  */
7720           struct group_list * g;
7721
7722           if (section_headers_groups == NULL
7723               || section_headers_groups [i] == NULL)
7724             i = filedata->file_header.e_shnum;
7725           else
7726             {
7727               g = section_headers_groups [i]->root;
7728
7729               for (; g != NULL; g = g->next)
7730                 {
7731                   sec = filedata->section_headers + g->section_index;
7732
7733                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7734                     break;
7735                 }
7736
7737               if (g == NULL)
7738                 i = filedata->file_header.e_shnum;
7739             }
7740         }
7741       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7742         {
7743           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
7744           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7745           suffix = SECTION_NAME (unwsec) + len;
7746           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7747                ++i, ++sec)
7748             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7749                 && streq (SECTION_NAME (sec) + len2, suffix))
7750               break;
7751         }
7752       else
7753         {
7754           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7755              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
7756           len = sizeof (ELF_STRING_ia64_unwind) - 1;
7757           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7758           suffix = "";
7759           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7760             suffix = SECTION_NAME (unwsec) + len;
7761           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7762                ++i, ++sec)
7763             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7764                 && streq (SECTION_NAME (sec) + len2, suffix))
7765               break;
7766         }
7767
7768       if (i == filedata->file_header.e_shnum)
7769         {
7770           printf (_("\nCould not find unwind info section for "));
7771
7772           if (filedata->string_table == NULL)
7773             printf ("%d", unwsec->sh_name);
7774           else
7775             printf ("'%s'", printable_section_name (filedata, unwsec));
7776         }
7777       else
7778         {
7779           aux.info_addr = sec->sh_addr;
7780           aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
7781                                                  sec->sh_size,
7782                                                  _("unwind info"));
7783           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7784
7785           printf (_("\nUnwind section "));
7786
7787           if (filedata->string_table == NULL)
7788             printf ("%d", unwsec->sh_name);
7789           else
7790             printf ("'%s'", printable_section_name (filedata, unwsec));
7791
7792           printf (_(" at offset 0x%lx contains %lu entries:\n"),
7793                   (unsigned long) unwsec->sh_offset,
7794                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7795
7796           if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
7797               && aux.table_len > 0)
7798             dump_ia64_unwind (filedata, & aux);
7799
7800           if (aux.table)
7801             free ((char *) aux.table);
7802           if (aux.info)
7803             free ((char *) aux.info);
7804           aux.table = NULL;
7805           aux.info = NULL;
7806         }
7807     }
7808
7809   if (aux.symtab)
7810     free (aux.symtab);
7811   if (aux.strtab)
7812     free ((char *) aux.strtab);
7813
7814   return res;
7815 }
7816
7817 struct hppa_unw_table_entry
7818 {
7819   struct absaddr start;
7820   struct absaddr end;
7821   unsigned int Cannot_unwind:1;                 /* 0 */
7822   unsigned int Millicode:1;                     /* 1 */
7823   unsigned int Millicode_save_sr0:1;            /* 2 */
7824   unsigned int Region_description:2;            /* 3..4 */
7825   unsigned int reserved1:1;                     /* 5 */
7826   unsigned int Entry_SR:1;                      /* 6 */
7827   unsigned int Entry_FR:4;     /* Number saved     7..10 */
7828   unsigned int Entry_GR:5;     /* Number saved     11..15 */
7829   unsigned int Args_stored:1;                   /* 16 */
7830   unsigned int Variable_Frame:1;                /* 17 */
7831   unsigned int Separate_Package_Body:1;         /* 18 */
7832   unsigned int Frame_Extension_Millicode:1;     /* 19 */
7833   unsigned int Stack_Overflow_Check:1;          /* 20 */
7834   unsigned int Two_Instruction_SP_Increment:1;  /* 21 */
7835   unsigned int Ada_Region:1;                    /* 22 */
7836   unsigned int cxx_info:1;                      /* 23 */
7837   unsigned int cxx_try_catch:1;                 /* 24 */
7838   unsigned int sched_entry_seq:1;               /* 25 */
7839   unsigned int reserved2:1;                     /* 26 */
7840   unsigned int Save_SP:1;                       /* 27 */
7841   unsigned int Save_RP:1;                       /* 28 */
7842   unsigned int Save_MRP_in_frame:1;             /* 29 */
7843   unsigned int extn_ptr_defined:1;              /* 30 */
7844   unsigned int Cleanup_defined:1;               /* 31 */
7845
7846   unsigned int MPE_XL_interrupt_marker:1;       /* 0 */
7847   unsigned int HP_UX_interrupt_marker:1;        /* 1 */
7848   unsigned int Large_frame:1;                   /* 2 */
7849   unsigned int Pseudo_SP_Set:1;                 /* 3 */
7850   unsigned int reserved4:1;                     /* 4 */
7851   unsigned int Total_frame_size:27;             /* 5..31 */
7852 };
7853
7854 struct hppa_unw_aux_info
7855 {
7856   struct hppa_unw_table_entry *  table;         /* Unwind table.  */
7857   unsigned long                  table_len;     /* Length of unwind table.  */
7858   bfd_vma                        seg_base;      /* Starting address of segment.  */
7859   Elf_Internal_Sym *             symtab;        /* The symbol table.  */
7860   unsigned long                  nsyms;         /* Number of symbols.  */
7861   Elf_Internal_Sym *             funtab;        /* Sorted table of STT_FUNC symbols.  */
7862   unsigned long                  nfuns;         /* Number of entries in funtab.  */
7863   char *                         strtab;        /* The string table.  */
7864   unsigned long                  strtab_size;   /* Size of string table.  */
7865 };
7866
7867 static bfd_boolean
7868 dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
7869 {
7870   struct hppa_unw_table_entry * tp;
7871   unsigned long j, nfuns;
7872   bfd_boolean res = TRUE;
7873
7874   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7875   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7876     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7877       aux->funtab[nfuns++] = aux->symtab[j];
7878   aux->nfuns = nfuns;
7879   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7880
7881   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7882     {
7883       bfd_vma offset;
7884       const char * procname;
7885
7886       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7887                                aux->strtab_size, tp->start, &procname,
7888                                &offset);
7889
7890       fputs ("\n<", stdout);
7891
7892       if (procname)
7893         {
7894           fputs (procname, stdout);
7895
7896           if (offset)
7897             printf ("+%lx", (unsigned long) offset);
7898         }
7899
7900       fputs (">: [", stdout);
7901       print_vma (tp->start.offset, PREFIX_HEX);
7902       fputc ('-', stdout);
7903       print_vma (tp->end.offset, PREFIX_HEX);
7904       printf ("]\n\t");
7905
7906 #define PF(_m) if (tp->_m) printf (#_m " ");
7907 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7908       PF(Cannot_unwind);
7909       PF(Millicode);
7910       PF(Millicode_save_sr0);
7911       /* PV(Region_description);  */
7912       PF(Entry_SR);
7913       PV(Entry_FR);
7914       PV(Entry_GR);
7915       PF(Args_stored);
7916       PF(Variable_Frame);
7917       PF(Separate_Package_Body);
7918       PF(Frame_Extension_Millicode);
7919       PF(Stack_Overflow_Check);
7920       PF(Two_Instruction_SP_Increment);
7921       PF(Ada_Region);
7922       PF(cxx_info);
7923       PF(cxx_try_catch);
7924       PF(sched_entry_seq);
7925       PF(Save_SP);
7926       PF(Save_RP);
7927       PF(Save_MRP_in_frame);
7928       PF(extn_ptr_defined);
7929       PF(Cleanup_defined);
7930       PF(MPE_XL_interrupt_marker);
7931       PF(HP_UX_interrupt_marker);
7932       PF(Large_frame);
7933       PF(Pseudo_SP_Set);
7934       PV(Total_frame_size);
7935 #undef PF
7936 #undef PV
7937     }
7938
7939   printf ("\n");
7940
7941   free (aux->funtab);
7942
7943   return res;
7944 }
7945
7946 static bfd_boolean
7947 slurp_hppa_unwind_table (Filedata *                  filedata,
7948                          struct hppa_unw_aux_info *  aux,
7949                          Elf_Internal_Shdr *         sec)
7950 {
7951   unsigned long size, unw_ent_size, nentries, nrelas, i;
7952   Elf_Internal_Phdr * seg;
7953   struct hppa_unw_table_entry * tep;
7954   Elf_Internal_Shdr * relsec;
7955   Elf_Internal_Rela * rela;
7956   Elf_Internal_Rela * rp;
7957   unsigned char * table;
7958   unsigned char * tp;
7959   Elf_Internal_Sym * sym;
7960   const char * relname;
7961
7962   /* First, find the starting address of the segment that includes
7963      this section.  */
7964   if (filedata->file_header.e_phnum)
7965     {
7966       if (! get_program_headers (filedata))
7967         return FALSE;
7968
7969       for (seg = filedata->program_headers;
7970            seg < filedata->program_headers + filedata->file_header.e_phnum;
7971            ++seg)
7972         {
7973           if (seg->p_type != PT_LOAD)
7974             continue;
7975
7976           if (sec->sh_addr >= seg->p_vaddr
7977               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7978             {
7979               aux->seg_base = seg->p_vaddr;
7980               break;
7981             }
7982         }
7983     }
7984
7985   /* Second, build the unwind table from the contents of the unwind
7986      section.  */
7987   size = sec->sh_size;
7988   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7989                                       _("unwind table"));
7990   if (!table)
7991     return FALSE;
7992
7993   unw_ent_size = 16;
7994   nentries = size / unw_ent_size;
7995   size = unw_ent_size * nentries;
7996
7997   tep = aux->table = (struct hppa_unw_table_entry *)
7998       xcmalloc (nentries, sizeof (aux->table[0]));
7999
8000   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
8001     {
8002       unsigned int tmp1, tmp2;
8003
8004       tep->start.section = SHN_UNDEF;
8005       tep->end.section   = SHN_UNDEF;
8006
8007       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
8008       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
8009       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
8010       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
8011
8012       tep->start.offset += aux->seg_base;
8013       tep->end.offset   += aux->seg_base;
8014
8015       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
8016       tep->Millicode = (tmp1 >> 30) & 0x1;
8017       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
8018       tep->Region_description = (tmp1 >> 27) & 0x3;
8019       tep->reserved1 = (tmp1 >> 26) & 0x1;
8020       tep->Entry_SR = (tmp1 >> 25) & 0x1;
8021       tep->Entry_FR = (tmp1 >> 21) & 0xf;
8022       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
8023       tep->Args_stored = (tmp1 >> 15) & 0x1;
8024       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
8025       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
8026       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
8027       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
8028       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
8029       tep->Ada_Region = (tmp1 >> 9) & 0x1;
8030       tep->cxx_info = (tmp1 >> 8) & 0x1;
8031       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
8032       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
8033       tep->reserved2 = (tmp1 >> 5) & 0x1;
8034       tep->Save_SP = (tmp1 >> 4) & 0x1;
8035       tep->Save_RP = (tmp1 >> 3) & 0x1;
8036       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
8037       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
8038       tep->Cleanup_defined = tmp1 & 0x1;
8039
8040       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
8041       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
8042       tep->Large_frame = (tmp2 >> 29) & 0x1;
8043       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
8044       tep->reserved4 = (tmp2 >> 27) & 0x1;
8045       tep->Total_frame_size = tmp2 & 0x7ffffff;
8046     }
8047   free (table);
8048
8049   /* Third, apply any relocations to the unwind table.  */
8050   for (relsec = filedata->section_headers;
8051        relsec < filedata->section_headers + filedata->file_header.e_shnum;
8052        ++relsec)
8053     {
8054       if (relsec->sh_type != SHT_RELA
8055           || relsec->sh_info >= filedata->file_header.e_shnum
8056           || filedata->section_headers + relsec->sh_info != sec)
8057         continue;
8058
8059       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
8060                               & rela, & nrelas))
8061         return FALSE;
8062
8063       for (rp = rela; rp < rela + nrelas; ++rp)
8064         {
8065           unsigned int sym_ndx;
8066           unsigned int r_type = get_reloc_type (filedata, rp->r_info);
8067           relname = elf_hppa_reloc_type (r_type);
8068
8069           if (relname == NULL)
8070             {
8071               warn (_("Skipping unknown relocation type: %u\n"), r_type);
8072               continue;
8073             }
8074
8075           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
8076           if (! const_strneq (relname, "R_PARISC_SEGREL"))
8077             {
8078               warn (_("Skipping unexpected relocation type: %s\n"), relname);
8079               continue;
8080             }
8081
8082           i = rp->r_offset / unw_ent_size;
8083           if (i >= aux->table_len)
8084             {
8085               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
8086               continue;
8087             }
8088
8089           sym_ndx = get_reloc_symindex (rp->r_info);
8090           if (sym_ndx >= aux->nsyms)
8091             {
8092               warn (_("Skipping reloc with invalid symbol index: %u\n"),
8093                     sym_ndx);
8094               continue;
8095             }
8096           sym = aux->symtab + sym_ndx;
8097
8098           switch ((rp->r_offset % unw_ent_size) / 4)
8099             {
8100             case 0:
8101               aux->table[i].start.section = sym->st_shndx;
8102               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
8103               break;
8104             case 1:
8105               aux->table[i].end.section   = sym->st_shndx;
8106               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
8107               break;
8108             default:
8109               break;
8110             }
8111         }
8112
8113       free (rela);
8114     }
8115
8116   aux->table_len = nentries;
8117
8118   return TRUE;
8119 }
8120
8121 static bfd_boolean
8122 hppa_process_unwind (Filedata * filedata)
8123 {
8124   struct hppa_unw_aux_info aux;
8125   Elf_Internal_Shdr * unwsec = NULL;
8126   Elf_Internal_Shdr * strsec;
8127   Elf_Internal_Shdr * sec;
8128   unsigned long i;
8129   bfd_boolean res = TRUE;
8130
8131   if (filedata->string_table == NULL)
8132     return FALSE;
8133
8134   memset (& aux, 0, sizeof (aux));
8135
8136   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8137     {
8138       if (sec->sh_type == SHT_SYMTAB
8139           && sec->sh_link < filedata->file_header.e_shnum)
8140         {
8141           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
8142
8143           strsec = filedata->section_headers + sec->sh_link;
8144           if (aux.strtab != NULL)
8145             {
8146               error (_("Multiple auxillary string tables encountered\n"));
8147               free (aux.strtab);
8148               res = FALSE;
8149             }
8150           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
8151                                           1, strsec->sh_size,
8152                                           _("string table"));
8153           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8154         }
8155       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8156         unwsec = sec;
8157     }
8158
8159   if (!unwsec)
8160     printf (_("\nThere are no unwind sections in this file.\n"));
8161
8162   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8163     {
8164       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8165         {
8166           unsigned long num_unwind = sec->sh_size / 16;
8167
8168           printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8169                             "contains %lu entry:\n",
8170                             "\nUnwind section '%s' at offset 0x%lx "
8171                             "contains %lu entries:\n",
8172                             num_unwind),
8173                   printable_section_name (filedata, sec),
8174                   (unsigned long) sec->sh_offset,
8175                   num_unwind);
8176
8177           if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8178             res = FALSE;
8179
8180           if (res && aux.table_len > 0)
8181             {
8182               if (! dump_hppa_unwind (filedata, &aux))
8183                 res = FALSE;
8184             }
8185
8186           if (aux.table)
8187             free ((char *) aux.table);
8188           aux.table = NULL;
8189         }
8190     }
8191
8192   if (aux.symtab)
8193     free (aux.symtab);
8194   if (aux.strtab)
8195     free ((char *) aux.strtab);
8196
8197   return res;
8198 }
8199
8200 struct arm_section
8201 {
8202   unsigned char *      data;            /* The unwind data.  */
8203   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
8204   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
8205   unsigned long        nrelas;          /* The number of relocations.  */
8206   unsigned int         rel_type;        /* REL or RELA ?  */
8207   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
8208 };
8209
8210 struct arm_unw_aux_info
8211 {
8212   Filedata *          filedata;         /* The file containing the unwind sections.  */
8213   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
8214   unsigned long       nsyms;            /* Number of symbols.  */
8215   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
8216   unsigned long       nfuns;            /* Number of these symbols.  */
8217   char *              strtab;           /* The file's string table.  */
8218   unsigned long       strtab_size;      /* Size of string table.  */
8219 };
8220
8221 static const char *
8222 arm_print_vma_and_name (Filedata *                 filedata,
8223                         struct arm_unw_aux_info *  aux,
8224                         bfd_vma                    fn,
8225                         struct absaddr             addr)
8226 {
8227   const char *procname;
8228   bfd_vma sym_offset;
8229
8230   if (addr.section == SHN_UNDEF)
8231     addr.offset = fn;
8232
8233   find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8234                            aux->strtab_size, addr, &procname,
8235                            &sym_offset);
8236
8237   print_vma (fn, PREFIX_HEX);
8238
8239   if (procname)
8240     {
8241       fputs (" <", stdout);
8242       fputs (procname, stdout);
8243
8244       if (sym_offset)
8245         printf ("+0x%lx", (unsigned long) sym_offset);
8246       fputc ('>', stdout);
8247     }
8248
8249   return procname;
8250 }
8251
8252 static void
8253 arm_free_section (struct arm_section *arm_sec)
8254 {
8255   if (arm_sec->data != NULL)
8256     free (arm_sec->data);
8257
8258   if (arm_sec->rela != NULL)
8259     free (arm_sec->rela);
8260 }
8261
8262 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8263       cached section and install SEC instead.
8264    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8265       and return its valued in * WORDP, relocating if necessary.
8266    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8267       relocation's offset in ADDR.
8268    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8269       into the string table of the symbol associated with the reloc.  If no
8270       reloc was applied store -1 there.
8271    5) Return TRUE upon success, FALSE otherwise.  */
8272
8273 static bfd_boolean
8274 get_unwind_section_word (Filedata *                 filedata,
8275                          struct arm_unw_aux_info *  aux,
8276                          struct arm_section *       arm_sec,
8277                          Elf_Internal_Shdr *        sec,
8278                          bfd_vma                    word_offset,
8279                          unsigned int *             wordp,
8280                          struct absaddr *           addr,
8281                          bfd_vma *                  sym_name)
8282 {
8283   Elf_Internal_Rela *rp;
8284   Elf_Internal_Sym *sym;
8285   const char * relname;
8286   unsigned int word;
8287   bfd_boolean wrapped;
8288
8289   if (sec == NULL || arm_sec == NULL)
8290     return FALSE;
8291
8292   addr->section = SHN_UNDEF;
8293   addr->offset = 0;
8294
8295   if (sym_name != NULL)
8296     *sym_name = (bfd_vma) -1;
8297
8298   /* If necessary, update the section cache.  */
8299   if (sec != arm_sec->sec)
8300     {
8301       Elf_Internal_Shdr *relsec;
8302
8303       arm_free_section (arm_sec);
8304
8305       arm_sec->sec = sec;
8306       arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8307                                 sec->sh_size, _("unwind data"));
8308       arm_sec->rela = NULL;
8309       arm_sec->nrelas = 0;
8310
8311       for (relsec = filedata->section_headers;
8312            relsec < filedata->section_headers + filedata->file_header.e_shnum;
8313            ++relsec)
8314         {
8315           if (relsec->sh_info >= filedata->file_header.e_shnum
8316               || filedata->section_headers + relsec->sh_info != sec
8317               /* PR 15745: Check the section type as well.  */
8318               || (relsec->sh_type != SHT_REL
8319                   && relsec->sh_type != SHT_RELA))
8320             continue;
8321
8322           arm_sec->rel_type = relsec->sh_type;
8323           if (relsec->sh_type == SHT_REL)
8324             {
8325               if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8326                                      relsec->sh_size,
8327                                      & arm_sec->rela, & arm_sec->nrelas))
8328                 return FALSE;
8329             }
8330           else /* relsec->sh_type == SHT_RELA */
8331             {
8332               if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8333                                       relsec->sh_size,
8334                                       & arm_sec->rela, & arm_sec->nrelas))
8335                 return FALSE;
8336             }
8337           break;
8338         }
8339
8340       arm_sec->next_rela = arm_sec->rela;
8341     }
8342
8343   /* If there is no unwind data we can do nothing.  */
8344   if (arm_sec->data == NULL)
8345     return FALSE;
8346
8347   /* If the offset is invalid then fail.  */
8348   if (/* PR 21343 *//* PR 18879 */
8349       sec->sh_size < 4
8350       || word_offset > (sec->sh_size - 4)
8351       || ((bfd_signed_vma) word_offset) < 0)
8352     return FALSE;
8353
8354   /* Get the word at the required offset.  */
8355   word = byte_get (arm_sec->data + word_offset, 4);
8356
8357   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
8358   if (arm_sec->rela == NULL)
8359     {
8360       * wordp = word;
8361       return TRUE;
8362     }
8363
8364   /* Look through the relocs to find the one that applies to the provided offset.  */
8365   wrapped = FALSE;
8366   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8367     {
8368       bfd_vma prelval, offset;
8369
8370       if (rp->r_offset > word_offset && !wrapped)
8371         {
8372           rp = arm_sec->rela;
8373           wrapped = TRUE;
8374         }
8375       if (rp->r_offset > word_offset)
8376         break;
8377
8378       if (rp->r_offset & 3)
8379         {
8380           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8381                 (unsigned long) rp->r_offset);
8382           continue;
8383         }
8384
8385       if (rp->r_offset < word_offset)
8386         continue;
8387
8388       /* PR 17531: file: 027-161405-0.004  */
8389       if (aux->symtab == NULL)
8390         continue;
8391
8392       if (arm_sec->rel_type == SHT_REL)
8393         {
8394           offset = word & 0x7fffffff;
8395           if (offset & 0x40000000)
8396             offset |= ~ (bfd_vma) 0x7fffffff;
8397         }
8398       else if (arm_sec->rel_type == SHT_RELA)
8399         offset = rp->r_addend;
8400       else
8401         {
8402           error (_("Unknown section relocation type %d encountered\n"),
8403                  arm_sec->rel_type);
8404           break;
8405         }
8406
8407       /* PR 17531 file: 027-1241568-0.004.  */
8408       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8409         {
8410           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8411                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8412           break;
8413         }
8414
8415       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8416       offset += sym->st_value;
8417       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8418
8419       /* Check that we are processing the expected reloc type.  */
8420       if (filedata->file_header.e_machine == EM_ARM)
8421         {
8422           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8423           if (relname == NULL)
8424             {
8425               warn (_("Skipping unknown ARM relocation type: %d\n"),
8426                     (int) ELF32_R_TYPE (rp->r_info));
8427               continue;
8428             }
8429
8430           if (streq (relname, "R_ARM_NONE"))
8431               continue;
8432
8433           if (! streq (relname, "R_ARM_PREL31"))
8434             {
8435               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8436               continue;
8437             }
8438         }
8439       else if (filedata->file_header.e_machine == EM_TI_C6000)
8440         {
8441           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8442           if (relname == NULL)
8443             {
8444               warn (_("Skipping unknown C6000 relocation type: %d\n"),
8445                     (int) ELF32_R_TYPE (rp->r_info));
8446               continue;
8447             }
8448
8449           if (streq (relname, "R_C6000_NONE"))
8450             continue;
8451
8452           if (! streq (relname, "R_C6000_PREL31"))
8453             {
8454               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8455               continue;
8456             }
8457
8458           prelval >>= 1;
8459         }
8460       else
8461         {
8462           /* This function currently only supports ARM and TI unwinders.  */
8463           warn (_("Only TI and ARM unwinders are currently supported\n"));
8464           break;
8465         }
8466
8467       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8468       addr->section = sym->st_shndx;
8469       addr->offset = offset;
8470
8471       if (sym_name)
8472         * sym_name = sym->st_name;
8473       break;
8474     }
8475
8476   *wordp = word;
8477   arm_sec->next_rela = rp;
8478
8479   return TRUE;
8480 }
8481
8482 static const char *tic6x_unwind_regnames[16] =
8483 {
8484   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8485   "A14", "A13", "A12", "A11", "A10",
8486   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8487 };
8488
8489 static void
8490 decode_tic6x_unwind_regmask (unsigned int mask)
8491 {
8492   int i;
8493
8494   for (i = 12; mask; mask >>= 1, i--)
8495     {
8496       if (mask & 1)
8497         {
8498           fputs (tic6x_unwind_regnames[i], stdout);
8499           if (mask > 1)
8500             fputs (", ", stdout);
8501         }
8502     }
8503 }
8504
8505 #define ADVANCE                                                 \
8506   if (remaining == 0 && more_words)                             \
8507     {                                                           \
8508       data_offset += 4;                                         \
8509       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec,     \
8510                                      data_offset, & word, & addr, NULL))        \
8511         return FALSE;                                           \
8512       remaining = 4;                                            \
8513       more_words--;                                             \
8514     }                                                           \
8515
8516 #define GET_OP(OP)                      \
8517   ADVANCE;                              \
8518   if (remaining)                        \
8519     {                                   \
8520       remaining--;                      \
8521       (OP) = word >> 24;                \
8522       word <<= 8;                       \
8523     }                                   \
8524   else                                  \
8525     {                                   \
8526       printf (_("[Truncated opcode]\n"));       \
8527       return FALSE;                     \
8528     }                                   \
8529   printf ("0x%02x ", OP)
8530
8531 static bfd_boolean
8532 decode_arm_unwind_bytecode (Filedata *                 filedata,
8533                             struct arm_unw_aux_info *  aux,
8534                             unsigned int               word,
8535                             unsigned int               remaining,
8536                             unsigned int               more_words,
8537                             bfd_vma                    data_offset,
8538                             Elf_Internal_Shdr *        data_sec,
8539                             struct arm_section *       data_arm_sec)
8540 {
8541   struct absaddr addr;
8542   bfd_boolean res = TRUE;
8543
8544   /* Decode the unwinding instructions.  */
8545   while (1)
8546     {
8547       unsigned int op, op2;
8548
8549       ADVANCE;
8550       if (remaining == 0)
8551         break;
8552       remaining--;
8553       op = word >> 24;
8554       word <<= 8;
8555
8556       printf ("  0x%02x ", op);
8557
8558       if ((op & 0xc0) == 0x00)
8559         {
8560           int offset = ((op & 0x3f) << 2) + 4;
8561
8562           printf ("     vsp = vsp + %d", offset);
8563         }
8564       else if ((op & 0xc0) == 0x40)
8565         {
8566           int offset = ((op & 0x3f) << 2) + 4;
8567
8568           printf ("     vsp = vsp - %d", offset);
8569         }
8570       else if ((op & 0xf0) == 0x80)
8571         {
8572           GET_OP (op2);
8573           if (op == 0x80 && op2 == 0)
8574             printf (_("Refuse to unwind"));
8575           else
8576             {
8577               unsigned int mask = ((op & 0x0f) << 8) | op2;
8578               bfd_boolean first = TRUE;
8579               int i;
8580
8581               printf ("pop {");
8582               for (i = 0; i < 12; i++)
8583                 if (mask & (1 << i))
8584                   {
8585                     if (first)
8586                       first = FALSE;
8587                     else
8588                       printf (", ");
8589                     printf ("r%d", 4 + i);
8590                   }
8591               printf ("}");
8592             }
8593         }
8594       else if ((op & 0xf0) == 0x90)
8595         {
8596           if (op == 0x9d || op == 0x9f)
8597             printf (_("     [Reserved]"));
8598           else
8599             printf ("     vsp = r%d", op & 0x0f);
8600         }
8601       else if ((op & 0xf0) == 0xa0)
8602         {
8603           int end = 4 + (op & 0x07);
8604           bfd_boolean first = TRUE;
8605           int i;
8606
8607           printf ("     pop {");
8608           for (i = 4; i <= end; i++)
8609             {
8610               if (first)
8611                 first = FALSE;
8612               else
8613                 printf (", ");
8614               printf ("r%d", i);
8615             }
8616           if (op & 0x08)
8617             {
8618               if (!first)
8619                 printf (", ");
8620               printf ("r14");
8621             }
8622           printf ("}");
8623         }
8624       else if (op == 0xb0)
8625         printf (_("     finish"));
8626       else if (op == 0xb1)
8627         {
8628           GET_OP (op2);
8629           if (op2 == 0 || (op2 & 0xf0) != 0)
8630             printf (_("[Spare]"));
8631           else
8632             {
8633               unsigned int mask = op2 & 0x0f;
8634               bfd_boolean first = TRUE;
8635               int i;
8636
8637               printf ("pop {");
8638               for (i = 0; i < 12; i++)
8639                 if (mask & (1 << i))
8640                   {
8641                     if (first)
8642                       first = FALSE;
8643                     else
8644                       printf (", ");
8645                     printf ("r%d", i);
8646                   }
8647               printf ("}");
8648             }
8649         }
8650       else if (op == 0xb2)
8651         {
8652           unsigned char buf[9];
8653           unsigned int i, len;
8654           unsigned long offset;
8655
8656           for (i = 0; i < sizeof (buf); i++)
8657             {
8658               GET_OP (buf[i]);
8659               if ((buf[i] & 0x80) == 0)
8660                 break;
8661             }
8662           if (i == sizeof (buf))
8663             {
8664               error (_("corrupt change to vsp"));
8665               res = FALSE;
8666             }
8667           else
8668             {
8669               offset = read_uleb128 (buf, &len, buf + i + 1);
8670               assert (len == i + 1);
8671               offset = offset * 4 + 0x204;
8672               printf ("vsp = vsp + %ld", offset);
8673             }
8674         }
8675       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8676         {
8677           unsigned int first, last;
8678
8679           GET_OP (op2);
8680           first = op2 >> 4;
8681           last = op2 & 0x0f;
8682           if (op == 0xc8)
8683             first = first + 16;
8684           printf ("pop {D%d", first);
8685           if (last)
8686             printf ("-D%d", first + last);
8687           printf ("}");
8688         }
8689       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8690         {
8691           unsigned int count = op & 0x07;
8692
8693           printf ("pop {D8");
8694           if (count)
8695             printf ("-D%d", 8 + count);
8696           printf ("}");
8697         }
8698       else if (op >= 0xc0 && op <= 0xc5)
8699         {
8700           unsigned int count = op & 0x07;
8701
8702           printf ("     pop {wR10");
8703           if (count)
8704             printf ("-wR%d", 10 + count);
8705           printf ("}");
8706         }
8707       else if (op == 0xc6)
8708         {
8709           unsigned int first, last;
8710
8711           GET_OP (op2);
8712           first = op2 >> 4;
8713           last = op2 & 0x0f;
8714           printf ("pop {wR%d", first);
8715           if (last)
8716             printf ("-wR%d", first + last);
8717           printf ("}");
8718         }
8719       else if (op == 0xc7)
8720         {
8721           GET_OP (op2);
8722           if (op2 == 0 || (op2 & 0xf0) != 0)
8723             printf (_("[Spare]"));
8724           else
8725             {
8726               unsigned int mask = op2 & 0x0f;
8727               bfd_boolean first = TRUE;
8728               int i;
8729
8730               printf ("pop {");
8731               for (i = 0; i < 4; i++)
8732                 if (mask & (1 << i))
8733                   {
8734                     if (first)
8735                       first = FALSE;
8736                     else
8737                       printf (", ");
8738                     printf ("wCGR%d", i);
8739                   }
8740               printf ("}");
8741             }
8742         }
8743       else
8744         {
8745           printf (_("     [unsupported opcode]"));
8746           res = FALSE;
8747         }
8748
8749       printf ("\n");
8750     }
8751
8752   return res;
8753 }
8754
8755 static bfd_boolean
8756 decode_tic6x_unwind_bytecode (Filedata *                 filedata,
8757                               struct arm_unw_aux_info *  aux,
8758                               unsigned int               word,
8759                               unsigned int               remaining,
8760                               unsigned int               more_words,
8761                               bfd_vma                    data_offset,
8762                               Elf_Internal_Shdr *        data_sec,
8763                               struct arm_section *       data_arm_sec)
8764 {
8765   struct absaddr addr;
8766
8767   /* Decode the unwinding instructions.  */
8768   while (1)
8769     {
8770       unsigned int op, op2;
8771
8772       ADVANCE;
8773       if (remaining == 0)
8774         break;
8775       remaining--;
8776       op = word >> 24;
8777       word <<= 8;
8778
8779       printf ("  0x%02x ", op);
8780
8781       if ((op & 0xc0) == 0x00)
8782         {
8783           int offset = ((op & 0x3f) << 3) + 8;
8784           printf ("     sp = sp + %d", offset);
8785         }
8786       else if ((op & 0xc0) == 0x80)
8787         {
8788           GET_OP (op2);
8789           if (op == 0x80 && op2 == 0)
8790             printf (_("Refuse to unwind"));
8791           else
8792             {
8793               unsigned int mask = ((op & 0x1f) << 8) | op2;
8794               if (op & 0x20)
8795                 printf ("pop compact {");
8796               else
8797                 printf ("pop {");
8798
8799               decode_tic6x_unwind_regmask (mask);
8800               printf("}");
8801             }
8802         }
8803       else if ((op & 0xf0) == 0xc0)
8804         {
8805           unsigned int reg;
8806           unsigned int nregs;
8807           unsigned int i;
8808           const char *name;
8809           struct
8810           {
8811             unsigned int offset;
8812             unsigned int reg;
8813           } regpos[16];
8814
8815           /* Scan entire instruction first so that GET_OP output is not
8816              interleaved with disassembly.  */
8817           nregs = 0;
8818           for (i = 0; nregs < (op & 0xf); i++)
8819             {
8820               GET_OP (op2);
8821               reg = op2 >> 4;
8822               if (reg != 0xf)
8823                 {
8824                   regpos[nregs].offset = i * 2;
8825                   regpos[nregs].reg = reg;
8826                   nregs++;
8827                 }
8828
8829               reg = op2 & 0xf;
8830               if (reg != 0xf)
8831                 {
8832                   regpos[nregs].offset = i * 2 + 1;
8833                   regpos[nregs].reg = reg;
8834                   nregs++;
8835                 }
8836             }
8837
8838           printf (_("pop frame {"));
8839           reg = nregs - 1;
8840           for (i = i * 2; i > 0; i--)
8841             {
8842               if (regpos[reg].offset == i - 1)
8843                 {
8844                   name = tic6x_unwind_regnames[regpos[reg].reg];
8845                   if (reg > 0)
8846                     reg--;
8847                 }
8848               else
8849                 name = _("[pad]");
8850
8851               fputs (name, stdout);
8852               if (i > 1)
8853                 printf (", ");
8854             }
8855
8856           printf ("}");
8857         }
8858       else if (op == 0xd0)
8859         printf ("     MOV FP, SP");
8860       else if (op == 0xd1)
8861         printf ("     __c6xabi_pop_rts");
8862       else if (op == 0xd2)
8863         {
8864           unsigned char buf[9];
8865           unsigned int i, len;
8866           unsigned long offset;
8867
8868           for (i = 0; i < sizeof (buf); i++)
8869             {
8870               GET_OP (buf[i]);
8871               if ((buf[i] & 0x80) == 0)
8872                 break;
8873             }
8874           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8875           if (i == sizeof (buf))
8876             {
8877               warn (_("Corrupt stack pointer adjustment detected\n"));
8878               return FALSE;
8879             }
8880
8881           offset = read_uleb128 (buf, &len, buf + i + 1);
8882           assert (len == i + 1);
8883           offset = offset * 8 + 0x408;
8884           printf (_("sp = sp + %ld"), offset);
8885         }
8886       else if ((op & 0xf0) == 0xe0)
8887         {
8888           if ((op & 0x0f) == 7)
8889             printf ("     RETURN");
8890           else
8891             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8892         }
8893       else
8894         {
8895           printf (_("     [unsupported opcode]"));
8896         }
8897       putchar ('\n');
8898     }
8899
8900   return TRUE;
8901 }
8902
8903 static bfd_vma
8904 arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
8905 {
8906   bfd_vma offset;
8907
8908   offset = word & 0x7fffffff;
8909   if (offset & 0x40000000)
8910     offset |= ~ (bfd_vma) 0x7fffffff;
8911
8912   if (filedata->file_header.e_machine == EM_TI_C6000)
8913     offset <<= 1;
8914
8915   return offset + where;
8916 }
8917
8918 static bfd_boolean
8919 decode_arm_unwind (Filedata *                 filedata,
8920                    struct arm_unw_aux_info *  aux,
8921                    unsigned int               word,
8922                    unsigned int               remaining,
8923                    bfd_vma                    data_offset,
8924                    Elf_Internal_Shdr *        data_sec,
8925                    struct arm_section *       data_arm_sec)
8926 {
8927   int per_index;
8928   unsigned int more_words = 0;
8929   struct absaddr addr;
8930   bfd_vma sym_name = (bfd_vma) -1;
8931   bfd_boolean res = TRUE;
8932
8933   if (remaining == 0)
8934     {
8935       /* Fetch the first word.
8936          Note - when decoding an object file the address extracted
8937          here will always be 0.  So we also pass in the sym_name
8938          parameter so that we can find the symbol associated with
8939          the personality routine.  */
8940       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
8941                                      & word, & addr, & sym_name))
8942         return FALSE;
8943
8944       remaining = 4;
8945     }
8946
8947   if ((word & 0x80000000) == 0)
8948     {
8949       /* Expand prel31 for personality routine.  */
8950       bfd_vma fn;
8951       const char *procname;
8952
8953       fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
8954       printf (_("  Personality routine: "));
8955       if (fn == 0
8956           && addr.section == SHN_UNDEF && addr.offset == 0
8957           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8958         {
8959           procname = aux->strtab + sym_name;
8960           print_vma (fn, PREFIX_HEX);
8961           if (procname)
8962             {
8963               fputs (" <", stdout);
8964               fputs (procname, stdout);
8965               fputc ('>', stdout);
8966             }
8967         }
8968       else
8969         procname = arm_print_vma_and_name (filedata, aux, fn, addr);
8970       fputc ('\n', stdout);
8971
8972       /* The GCC personality routines use the standard compact
8973          encoding, starting with one byte giving the number of
8974          words.  */
8975       if (procname != NULL
8976           && (const_strneq (procname, "__gcc_personality_v0")
8977               || const_strneq (procname, "__gxx_personality_v0")
8978               || const_strneq (procname, "__gcj_personality_v0")
8979               || const_strneq (procname, "__gnu_objc_personality_v0")))
8980         {
8981           remaining = 0;
8982           more_words = 1;
8983           ADVANCE;
8984           if (!remaining)
8985             {
8986               printf (_("  [Truncated data]\n"));
8987               return FALSE;
8988             }
8989           more_words = word >> 24;
8990           word <<= 8;
8991           remaining--;
8992           per_index = -1;
8993         }
8994       else
8995         return TRUE;
8996     }
8997   else
8998     {
8999       /* ARM EHABI Section 6.3:
9000
9001          An exception-handling table entry for the compact model looks like:
9002
9003            31 30-28 27-24 23-0
9004            -- ----- ----- ----
9005             1   0   index Data for personalityRoutine[index]    */
9006
9007       if (filedata->file_header.e_machine == EM_ARM
9008           && (word & 0x70000000))
9009         {
9010           warn (_("Corrupt ARM compact model table entry: %x \n"), word);
9011           res = FALSE;
9012         }
9013
9014       per_index = (word >> 24) & 0x7f;
9015       printf (_("  Compact model index: %d\n"), per_index);
9016       if (per_index == 0)
9017         {
9018           more_words = 0;
9019           word <<= 8;
9020           remaining--;
9021         }
9022       else if (per_index < 3)
9023         {
9024           more_words = (word >> 16) & 0xff;
9025           word <<= 16;
9026           remaining -= 2;
9027         }
9028     }
9029
9030   switch (filedata->file_header.e_machine)
9031     {
9032     case EM_ARM:
9033       if (per_index < 3)
9034         {
9035           if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
9036                                             data_offset, data_sec, data_arm_sec))
9037             res = FALSE;
9038         }
9039       else
9040         {
9041           warn (_("Unknown ARM compact model index encountered\n"));
9042           printf (_("  [reserved]\n"));
9043           res = FALSE;
9044         }
9045       break;
9046
9047     case EM_TI_C6000:
9048       if (per_index < 3)
9049         {
9050           if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
9051                                               data_offset, data_sec, data_arm_sec))
9052             res = FALSE;
9053         }
9054       else if (per_index < 5)
9055         {
9056           if (((word >> 17) & 0x7f) == 0x7f)
9057             printf (_("  Restore stack from frame pointer\n"));
9058           else
9059             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
9060           printf (_("  Registers restored: "));
9061           if (per_index == 4)
9062             printf (" (compact) ");
9063           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
9064           putchar ('\n');
9065           printf (_("  Return register: %s\n"),
9066                   tic6x_unwind_regnames[word & 0xf]);
9067         }
9068       else
9069         printf (_("  [reserved (%d)]\n"), per_index);
9070       break;
9071
9072     default:
9073       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9074              filedata->file_header.e_machine);
9075       res = FALSE;
9076     }
9077
9078   /* Decode the descriptors.  Not implemented.  */
9079
9080   return res;
9081 }
9082
9083 static bfd_boolean
9084 dump_arm_unwind (Filedata *                 filedata,
9085                  struct arm_unw_aux_info *  aux,
9086                  Elf_Internal_Shdr *        exidx_sec)
9087 {
9088   struct arm_section exidx_arm_sec, extab_arm_sec;
9089   unsigned int i, exidx_len;
9090   unsigned long j, nfuns;
9091   bfd_boolean res = TRUE;
9092
9093   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
9094   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
9095   exidx_len = exidx_sec->sh_size / 8;
9096
9097   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
9098   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
9099     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
9100       aux->funtab[nfuns++] = aux->symtab[j];
9101   aux->nfuns = nfuns;
9102   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
9103
9104   for (i = 0; i < exidx_len; i++)
9105     {
9106       unsigned int exidx_fn, exidx_entry;
9107       struct absaddr fn_addr, entry_addr;
9108       bfd_vma fn;
9109
9110       fputc ('\n', stdout);
9111
9112       if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9113                                      8 * i, & exidx_fn, & fn_addr, NULL)
9114           || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9115                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
9116         {
9117           free (aux->funtab);
9118           arm_free_section (& exidx_arm_sec);
9119           arm_free_section (& extab_arm_sec);
9120           return FALSE;
9121         }
9122
9123       /* ARM EHABI, Section 5:
9124          An index table entry consists of 2 words.
9125          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
9126       if (exidx_fn & 0x80000000)
9127         {
9128           warn (_("corrupt index table entry: %x\n"), exidx_fn);
9129           res = FALSE;
9130         }
9131
9132       fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9133
9134       arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9135       fputs (": ", stdout);
9136
9137       if (exidx_entry == 1)
9138         {
9139           print_vma (exidx_entry, PREFIX_HEX);
9140           fputs (" [cantunwind]\n", stdout);
9141         }
9142       else if (exidx_entry & 0x80000000)
9143         {
9144           print_vma (exidx_entry, PREFIX_HEX);
9145           fputc ('\n', stdout);
9146           decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9147         }
9148       else
9149         {
9150           bfd_vma table, table_offset = 0;
9151           Elf_Internal_Shdr *table_sec;
9152
9153           fputs ("@", stdout);
9154           table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9155           print_vma (table, PREFIX_HEX);
9156           printf ("\n");
9157
9158           /* Locate the matching .ARM.extab.  */
9159           if (entry_addr.section != SHN_UNDEF
9160               && entry_addr.section < filedata->file_header.e_shnum)
9161             {
9162               table_sec = filedata->section_headers + entry_addr.section;
9163               table_offset = entry_addr.offset;
9164               /* PR 18879 */
9165               if (table_offset > table_sec->sh_size
9166                   || ((bfd_signed_vma) table_offset) < 0)
9167                 {
9168                   warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9169                         (unsigned long) table_offset,
9170                         printable_section_name (filedata, table_sec));
9171                   res = FALSE;
9172                   continue;
9173                 }
9174             }
9175           else
9176             {
9177               table_sec = find_section_by_address (filedata, table);
9178               if (table_sec != NULL)
9179                 table_offset = table - table_sec->sh_addr;
9180             }
9181
9182           if (table_sec == NULL)
9183             {
9184               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9185                     (unsigned long) table);
9186               res = FALSE;
9187               continue;
9188             }
9189
9190           if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9191                                    &extab_arm_sec))
9192             res = FALSE;
9193         }
9194     }
9195
9196   printf ("\n");
9197
9198   free (aux->funtab);
9199   arm_free_section (&exidx_arm_sec);
9200   arm_free_section (&extab_arm_sec);
9201
9202   return res;
9203 }
9204
9205 /* Used for both ARM and C6X unwinding tables.  */
9206
9207 static bfd_boolean
9208 arm_process_unwind (Filedata * filedata)
9209 {
9210   struct arm_unw_aux_info aux;
9211   Elf_Internal_Shdr *unwsec = NULL;
9212   Elf_Internal_Shdr *strsec;
9213   Elf_Internal_Shdr *sec;
9214   unsigned long i;
9215   unsigned int sec_type;
9216   bfd_boolean res = TRUE;
9217
9218   switch (filedata->file_header.e_machine)
9219     {
9220     case EM_ARM:
9221       sec_type = SHT_ARM_EXIDX;
9222       break;
9223
9224     case EM_TI_C6000:
9225       sec_type = SHT_C6000_UNWIND;
9226       break;
9227
9228     default:
9229       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9230              filedata->file_header.e_machine);
9231       return FALSE;
9232     }
9233
9234   if (filedata->string_table == NULL)
9235     return FALSE;
9236
9237   memset (& aux, 0, sizeof (aux));
9238   aux.filedata = filedata;
9239
9240   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9241     {
9242       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < filedata->file_header.e_shnum)
9243         {
9244           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
9245
9246           strsec = filedata->section_headers + sec->sh_link;
9247
9248           /* PR binutils/17531 file: 011-12666-0.004.  */
9249           if (aux.strtab != NULL)
9250             {
9251               error (_("Multiple string tables found in file.\n"));
9252               free (aux.strtab);
9253               res = FALSE;
9254             }
9255           aux.strtab = get_data (NULL, filedata, strsec->sh_offset,
9256                                  1, strsec->sh_size, _("string table"));
9257           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9258         }
9259       else if (sec->sh_type == sec_type)
9260         unwsec = sec;
9261     }
9262
9263   if (unwsec == NULL)
9264     printf (_("\nThere are no unwind sections in this file.\n"));
9265   else
9266     for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9267       {
9268         if (sec->sh_type == sec_type)
9269           {
9270             unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9271             printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9272                               "contains %lu entry:\n",
9273                               "\nUnwind section '%s' at offset 0x%lx "
9274                               "contains %lu entries:\n",
9275                               num_unwind),
9276                     printable_section_name (filedata, sec),
9277                     (unsigned long) sec->sh_offset,
9278                     num_unwind);
9279
9280             if (! dump_arm_unwind (filedata, &aux, sec))
9281               res = FALSE;
9282           }
9283       }
9284
9285   if (aux.symtab)
9286     free (aux.symtab);
9287   if (aux.strtab)
9288     free ((char *) aux.strtab);
9289
9290   return res;
9291 }
9292
9293 static bfd_boolean
9294 process_unwind (Filedata * filedata)
9295 {
9296   struct unwind_handler
9297   {
9298     unsigned int machtype;
9299     bfd_boolean (* handler)(Filedata *);
9300   } handlers[] =
9301   {
9302     { EM_ARM, arm_process_unwind },
9303     { EM_IA_64, ia64_process_unwind },
9304     { EM_PARISC, hppa_process_unwind },
9305     { EM_TI_C6000, arm_process_unwind },
9306     { 0, NULL }
9307   };
9308   int i;
9309
9310   if (!do_unwind)
9311     return TRUE;
9312
9313   for (i = 0; handlers[i].handler != NULL; i++)
9314     if (filedata->file_header.e_machine == handlers[i].machtype)
9315       return handlers[i].handler (filedata);
9316
9317   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9318           get_machine_name (filedata->file_header.e_machine));
9319   return TRUE;
9320 }
9321
9322 static void
9323 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9324 {
9325   switch (entry->d_tag)
9326     {
9327     case DT_MIPS_FLAGS:
9328       if (entry->d_un.d_val == 0)
9329         printf (_("NONE"));
9330       else
9331         {
9332           static const char * opts[] =
9333           {
9334             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9335             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9336             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9337             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9338             "RLD_ORDER_SAFE"
9339           };
9340           unsigned int cnt;
9341           bfd_boolean first = TRUE;
9342
9343           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9344             if (entry->d_un.d_val & (1 << cnt))
9345               {
9346                 printf ("%s%s", first ? "" : " ", opts[cnt]);
9347                 first = FALSE;
9348               }
9349         }
9350       break;
9351
9352     case DT_MIPS_IVERSION:
9353       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9354         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9355       else
9356         {
9357           char buf[40];
9358           sprintf_vma (buf, entry->d_un.d_ptr);
9359           /* Note: coded this way so that there is a single string for translation.  */
9360           printf (_("<corrupt: %s>"), buf);
9361         }
9362       break;
9363
9364     case DT_MIPS_TIME_STAMP:
9365       {
9366         char timebuf[128];
9367         struct tm * tmp;
9368         time_t atime = entry->d_un.d_val;
9369
9370         tmp = gmtime (&atime);
9371         /* PR 17531: file: 6accc532.  */
9372         if (tmp == NULL)
9373           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9374         else
9375           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9376                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9377                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9378         printf (_("Time Stamp: %s"), timebuf);
9379       }
9380       break;
9381
9382     case DT_MIPS_RLD_VERSION:
9383     case DT_MIPS_LOCAL_GOTNO:
9384     case DT_MIPS_CONFLICTNO:
9385     case DT_MIPS_LIBLISTNO:
9386     case DT_MIPS_SYMTABNO:
9387     case DT_MIPS_UNREFEXTNO:
9388     case DT_MIPS_HIPAGENO:
9389     case DT_MIPS_DELTA_CLASS_NO:
9390     case DT_MIPS_DELTA_INSTANCE_NO:
9391     case DT_MIPS_DELTA_RELOC_NO:
9392     case DT_MIPS_DELTA_SYM_NO:
9393     case DT_MIPS_DELTA_CLASSSYM_NO:
9394     case DT_MIPS_COMPACT_SIZE:
9395       print_vma (entry->d_un.d_val, DEC);
9396       break;
9397
9398     default:
9399       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9400     }
9401     putchar ('\n');
9402 }
9403
9404 static void
9405 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9406 {
9407   switch (entry->d_tag)
9408     {
9409     case DT_HP_DLD_FLAGS:
9410       {
9411         static struct
9412         {
9413           long int bit;
9414           const char * str;
9415         }
9416         flags[] =
9417         {
9418           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9419           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9420           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9421           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9422           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9423           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9424           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9425           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9426           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9427           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9428           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9429           { DT_HP_GST, "HP_GST" },
9430           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9431           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9432           { DT_HP_NODELETE, "HP_NODELETE" },
9433           { DT_HP_GROUP, "HP_GROUP" },
9434           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9435         };
9436         bfd_boolean first = TRUE;
9437         size_t cnt;
9438         bfd_vma val = entry->d_un.d_val;
9439
9440         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9441           if (val & flags[cnt].bit)
9442             {
9443               if (! first)
9444                 putchar (' ');
9445               fputs (flags[cnt].str, stdout);
9446               first = FALSE;
9447               val ^= flags[cnt].bit;
9448             }
9449
9450         if (val != 0 || first)
9451           {
9452             if (! first)
9453               putchar (' ');
9454             print_vma (val, HEX);
9455           }
9456       }
9457       break;
9458
9459     default:
9460       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9461       break;
9462     }
9463   putchar ('\n');
9464 }
9465
9466 #ifdef BFD64
9467
9468 /* VMS vs Unix time offset and factor.  */
9469
9470 #define VMS_EPOCH_OFFSET 35067168000000000LL
9471 #define VMS_GRANULARITY_FACTOR 10000000
9472
9473 /* Display a VMS time in a human readable format.  */
9474
9475 static void
9476 print_vms_time (bfd_int64_t vmstime)
9477 {
9478   struct tm *tm;
9479   time_t unxtime;
9480
9481   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9482   tm = gmtime (&unxtime);
9483   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9484           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9485           tm->tm_hour, tm->tm_min, tm->tm_sec);
9486 }
9487 #endif /* BFD64 */
9488
9489 static void
9490 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9491 {
9492   switch (entry->d_tag)
9493     {
9494     case DT_IA_64_PLT_RESERVE:
9495       /* First 3 slots reserved.  */
9496       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9497       printf (" -- ");
9498       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9499       break;
9500
9501     case DT_IA_64_VMS_LINKTIME:
9502 #ifdef BFD64
9503       print_vms_time (entry->d_un.d_val);
9504 #endif
9505       break;
9506
9507     case DT_IA_64_VMS_LNKFLAGS:
9508       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9509       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9510         printf (" CALL_DEBUG");
9511       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9512         printf (" NOP0BUFS");
9513       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9514         printf (" P0IMAGE");
9515       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9516         printf (" MKTHREADS");
9517       if (entry->d_un.d_val & VMS_LF_UPCALLS)
9518         printf (" UPCALLS");
9519       if (entry->d_un.d_val & VMS_LF_IMGSTA)
9520         printf (" IMGSTA");
9521       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9522         printf (" INITIALIZE");
9523       if (entry->d_un.d_val & VMS_LF_MAIN)
9524         printf (" MAIN");
9525       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9526         printf (" EXE_INIT");
9527       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9528         printf (" TBK_IN_IMG");
9529       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9530         printf (" DBG_IN_IMG");
9531       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9532         printf (" TBK_IN_DSF");
9533       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9534         printf (" DBG_IN_DSF");
9535       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9536         printf (" SIGNATURES");
9537       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9538         printf (" REL_SEG_OFF");
9539       break;
9540
9541     default:
9542       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9543       break;
9544     }
9545   putchar ('\n');
9546 }
9547
9548 static bfd_boolean
9549 get_32bit_dynamic_section (Filedata * filedata)
9550 {
9551   Elf32_External_Dyn * edyn;
9552   Elf32_External_Dyn * ext;
9553   Elf_Internal_Dyn * entry;
9554
9555   edyn = (Elf32_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9556                                           dynamic_size, _("dynamic section"));
9557   if (!edyn)
9558     return FALSE;
9559
9560   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9561      might not have the luxury of section headers.  Look for the DT_NULL
9562      terminator to determine the number of entries.  */
9563   for (ext = edyn, dynamic_nent = 0;
9564        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9565        ext++)
9566     {
9567       dynamic_nent++;
9568       if (BYTE_GET (ext->d_tag) == DT_NULL)
9569         break;
9570     }
9571
9572   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9573                                                   sizeof (* entry));
9574   if (dynamic_section == NULL)
9575     {
9576       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9577              (unsigned long) dynamic_nent);
9578       free (edyn);
9579       return FALSE;
9580     }
9581
9582   for (ext = edyn, entry = dynamic_section;
9583        entry < dynamic_section + dynamic_nent;
9584        ext++, entry++)
9585     {
9586       entry->d_tag      = BYTE_GET (ext->d_tag);
9587       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9588     }
9589
9590   free (edyn);
9591
9592   return TRUE;
9593 }
9594
9595 static bfd_boolean
9596 get_64bit_dynamic_section (Filedata * filedata)
9597 {
9598   Elf64_External_Dyn * edyn;
9599   Elf64_External_Dyn * ext;
9600   Elf_Internal_Dyn * entry;
9601
9602   /* Read in the data.  */
9603   edyn = (Elf64_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9604                                           dynamic_size, _("dynamic section"));
9605   if (!edyn)
9606     return FALSE;
9607
9608   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9609      might not have the luxury of section headers.  Look for the DT_NULL
9610      terminator to determine the number of entries.  */
9611   for (ext = edyn, dynamic_nent = 0;
9612        /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer.  */
9613        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9614        ext++)
9615     {
9616       dynamic_nent++;
9617       if (BYTE_GET (ext->d_tag) == DT_NULL)
9618         break;
9619     }
9620
9621   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9622                                                   sizeof (* entry));
9623   if (dynamic_section == NULL)
9624     {
9625       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9626              (unsigned long) dynamic_nent);
9627       free (edyn);
9628       return FALSE;
9629     }
9630
9631   /* Convert from external to internal formats.  */
9632   for (ext = edyn, entry = dynamic_section;
9633        entry < dynamic_section + dynamic_nent;
9634        ext++, entry++)
9635     {
9636       entry->d_tag      = BYTE_GET (ext->d_tag);
9637       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9638     }
9639
9640   free (edyn);
9641
9642   return TRUE;
9643 }
9644
9645 static void
9646 print_dynamic_flags (bfd_vma flags)
9647 {
9648   bfd_boolean first = TRUE;
9649
9650   while (flags)
9651     {
9652       bfd_vma flag;
9653
9654       flag = flags & - flags;
9655       flags &= ~ flag;
9656
9657       if (first)
9658         first = FALSE;
9659       else
9660         putc (' ', stdout);
9661
9662       switch (flag)
9663         {
9664         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
9665         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
9666         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
9667         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
9668         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
9669         default:                fputs (_("unknown"), stdout); break;
9670         }
9671     }
9672   puts ("");
9673 }
9674
9675 /* Parse and display the contents of the dynamic section.  */
9676
9677 static bfd_boolean
9678 process_dynamic_section (Filedata * filedata)
9679 {
9680   Elf_Internal_Dyn * entry;
9681
9682   if (dynamic_size == 0)
9683     {
9684       if (do_dynamic)
9685         printf (_("\nThere is no dynamic section in this file.\n"));
9686
9687       return TRUE;
9688     }
9689
9690   if (is_32bit_elf)
9691     {
9692       if (! get_32bit_dynamic_section (filedata))
9693         return FALSE;
9694     }
9695   else
9696     {
9697       if (! get_64bit_dynamic_section (filedata))
9698         return FALSE;
9699     }
9700
9701   /* Find the appropriate symbol table.  */
9702   if (dynamic_symbols == NULL)
9703     {
9704       for (entry = dynamic_section;
9705            entry < dynamic_section + dynamic_nent;
9706            ++entry)
9707         {
9708           Elf_Internal_Shdr section;
9709
9710           if (entry->d_tag != DT_SYMTAB)
9711             continue;
9712
9713           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9714
9715           /* Since we do not know how big the symbol table is,
9716              we default to reading in the entire file (!) and
9717              processing that.  This is overkill, I know, but it
9718              should work.  */
9719           section.sh_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9720           if ((bfd_size_type) section.sh_offset > filedata->file_size)
9721             {
9722               /* See PR 21379 for a reproducer.  */
9723               error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9724               return FALSE;
9725             }
9726
9727           if (archive_file_offset != 0)
9728             section.sh_size = archive_file_size - section.sh_offset;
9729           else
9730             section.sh_size = filedata->file_size - section.sh_offset;
9731
9732           if (is_32bit_elf)
9733             section.sh_entsize = sizeof (Elf32_External_Sym);
9734           else
9735             section.sh_entsize = sizeof (Elf64_External_Sym);
9736           section.sh_name = filedata->string_table_length;
9737
9738           if (dynamic_symbols != NULL)
9739             {
9740               error (_("Multiple dynamic symbol table sections found\n"));
9741               free (dynamic_symbols);
9742             }
9743           dynamic_symbols = GET_ELF_SYMBOLS (filedata, &section, & num_dynamic_syms);
9744           if (num_dynamic_syms < 1)
9745             {
9746               error (_("Unable to determine the number of symbols to load\n"));
9747               continue;
9748             }
9749         }
9750     }
9751
9752   /* Similarly find a string table.  */
9753   if (dynamic_strings == NULL)
9754     {
9755       for (entry = dynamic_section;
9756            entry < dynamic_section + dynamic_nent;
9757            ++entry)
9758         {
9759           unsigned long offset;
9760           long str_tab_len;
9761
9762           if (entry->d_tag != DT_STRTAB)
9763             continue;
9764
9765           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9766
9767           /* Since we do not know how big the string table is,
9768              we default to reading in the entire file (!) and
9769              processing that.  This is overkill, I know, but it
9770              should work.  */
9771
9772           offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9773
9774           if (archive_file_offset != 0)
9775             str_tab_len = archive_file_size - offset;
9776           else
9777             str_tab_len = filedata->file_size - offset;
9778
9779           if (str_tab_len < 1)
9780             {
9781               error
9782                 (_("Unable to determine the length of the dynamic string table\n"));
9783               continue;
9784             }
9785
9786           if (dynamic_strings != NULL)
9787             {
9788               error (_("Multiple dynamic string tables found\n"));
9789               free (dynamic_strings);
9790             }
9791
9792           dynamic_strings = (char *) get_data (NULL, filedata, offset, 1,
9793                                                str_tab_len,
9794                                                _("dynamic string table"));
9795           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9796         }
9797     }
9798
9799   /* And find the syminfo section if available.  */
9800   if (dynamic_syminfo == NULL)
9801     {
9802       unsigned long syminsz = 0;
9803
9804       for (entry = dynamic_section;
9805            entry < dynamic_section + dynamic_nent;
9806            ++entry)
9807         {
9808           if (entry->d_tag == DT_SYMINENT)
9809             {
9810               /* Note: these braces are necessary to avoid a syntax
9811                  error from the SunOS4 C compiler.  */
9812               /* PR binutils/17531: A corrupt file can trigger this test.
9813                  So do not use an assert, instead generate an error message.  */
9814               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9815                 error (_("Bad value (%d) for SYMINENT entry\n"),
9816                        (int) entry->d_un.d_val);
9817             }
9818           else if (entry->d_tag == DT_SYMINSZ)
9819             syminsz = entry->d_un.d_val;
9820           else if (entry->d_tag == DT_SYMINFO)
9821             dynamic_syminfo_offset = offset_from_vma (filedata, entry->d_un.d_val,
9822                                                       syminsz);
9823         }
9824
9825       if (dynamic_syminfo_offset != 0 && syminsz != 0)
9826         {
9827           Elf_External_Syminfo * extsyminfo;
9828           Elf_External_Syminfo * extsym;
9829           Elf_Internal_Syminfo * syminfo;
9830
9831           /* There is a syminfo section.  Read the data.  */
9832           extsyminfo = (Elf_External_Syminfo *)
9833               get_data (NULL, filedata, dynamic_syminfo_offset, 1, syminsz,
9834                         _("symbol information"));
9835           if (!extsyminfo)
9836             return FALSE;
9837
9838           if (dynamic_syminfo != NULL)
9839             {
9840               error (_("Multiple dynamic symbol information sections found\n"));
9841               free (dynamic_syminfo);
9842             }
9843           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9844           if (dynamic_syminfo == NULL)
9845             {
9846               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9847                      (unsigned long) syminsz);
9848               return FALSE;
9849             }
9850
9851           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9852           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9853                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9854                ++syminfo, ++extsym)
9855             {
9856               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9857               syminfo->si_flags = BYTE_GET (extsym->si_flags);
9858             }
9859
9860           free (extsyminfo);
9861         }
9862     }
9863
9864   if (do_dynamic && dynamic_addr)
9865     printf (ngettext ("\nDynamic section at offset 0x%lx "
9866                       "contains %lu entry:\n",
9867                       "\nDynamic section at offset 0x%lx "
9868                       "contains %lu entries:\n",
9869                       dynamic_nent),
9870             dynamic_addr, (unsigned long) dynamic_nent);
9871   if (do_dynamic)
9872     printf (_("  Tag        Type                         Name/Value\n"));
9873
9874   for (entry = dynamic_section;
9875        entry < dynamic_section + dynamic_nent;
9876        entry++)
9877     {
9878       if (do_dynamic)
9879         {
9880           const char * dtype;
9881
9882           putchar (' ');
9883           print_vma (entry->d_tag, FULL_HEX);
9884           dtype = get_dynamic_type (filedata, entry->d_tag);
9885           printf (" (%s)%*s", dtype,
9886                   ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9887         }
9888
9889       switch (entry->d_tag)
9890         {
9891         case DT_FLAGS:
9892           if (do_dynamic)
9893             print_dynamic_flags (entry->d_un.d_val);
9894           break;
9895
9896         case DT_AUXILIARY:
9897         case DT_FILTER:
9898         case DT_CONFIG:
9899         case DT_DEPAUDIT:
9900         case DT_AUDIT:
9901           if (do_dynamic)
9902             {
9903               switch (entry->d_tag)
9904                 {
9905                 case DT_AUXILIARY:
9906                   printf (_("Auxiliary library"));
9907                   break;
9908
9909                 case DT_FILTER:
9910                   printf (_("Filter library"));
9911                   break;
9912
9913                 case DT_CONFIG:
9914                   printf (_("Configuration file"));
9915                   break;
9916
9917                 case DT_DEPAUDIT:
9918                   printf (_("Dependency audit library"));
9919                   break;
9920
9921                 case DT_AUDIT:
9922                   printf (_("Audit library"));
9923                   break;
9924                 }
9925
9926               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9927                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9928               else
9929                 {
9930                   printf (": ");
9931                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9932                   putchar ('\n');
9933                 }
9934             }
9935           break;
9936
9937         case DT_FEATURE:
9938           if (do_dynamic)
9939             {
9940               printf (_("Flags:"));
9941
9942               if (entry->d_un.d_val == 0)
9943                 printf (_(" None\n"));
9944               else
9945                 {
9946                   unsigned long int val = entry->d_un.d_val;
9947
9948                   if (val & DTF_1_PARINIT)
9949                     {
9950                       printf (" PARINIT");
9951                       val ^= DTF_1_PARINIT;
9952                     }
9953                   if (val & DTF_1_CONFEXP)
9954                     {
9955                       printf (" CONFEXP");
9956                       val ^= DTF_1_CONFEXP;
9957                     }
9958                   if (val != 0)
9959                     printf (" %lx", val);
9960                   puts ("");
9961                 }
9962             }
9963           break;
9964
9965         case DT_POSFLAG_1:
9966           if (do_dynamic)
9967             {
9968               printf (_("Flags:"));
9969
9970               if (entry->d_un.d_val == 0)
9971                 printf (_(" None\n"));
9972               else
9973                 {
9974                   unsigned long int val = entry->d_un.d_val;
9975
9976                   if (val & DF_P1_LAZYLOAD)
9977                     {
9978                       printf (" LAZYLOAD");
9979                       val ^= DF_P1_LAZYLOAD;
9980                     }
9981                   if (val & DF_P1_GROUPPERM)
9982                     {
9983                       printf (" GROUPPERM");
9984                       val ^= DF_P1_GROUPPERM;
9985                     }
9986                   if (val != 0)
9987                     printf (" %lx", val);
9988                   puts ("");
9989                 }
9990             }
9991           break;
9992
9993         case DT_FLAGS_1:
9994           if (do_dynamic)
9995             {
9996               printf (_("Flags:"));
9997               if (entry->d_un.d_val == 0)
9998                 printf (_(" None\n"));
9999               else
10000                 {
10001                   unsigned long int val = entry->d_un.d_val;
10002
10003                   if (val & DF_1_NOW)
10004                     {
10005                       printf (" NOW");
10006                       val ^= DF_1_NOW;
10007                     }
10008                   if (val & DF_1_GLOBAL)
10009                     {
10010                       printf (" GLOBAL");
10011                       val ^= DF_1_GLOBAL;
10012                     }
10013                   if (val & DF_1_GROUP)
10014                     {
10015                       printf (" GROUP");
10016                       val ^= DF_1_GROUP;
10017                     }
10018                   if (val & DF_1_NODELETE)
10019                     {
10020                       printf (" NODELETE");
10021                       val ^= DF_1_NODELETE;
10022                     }
10023                   if (val & DF_1_LOADFLTR)
10024                     {
10025                       printf (" LOADFLTR");
10026                       val ^= DF_1_LOADFLTR;
10027                     }
10028                   if (val & DF_1_INITFIRST)
10029                     {
10030                       printf (" INITFIRST");
10031                       val ^= DF_1_INITFIRST;
10032                     }
10033                   if (val & DF_1_NOOPEN)
10034                     {
10035                       printf (" NOOPEN");
10036                       val ^= DF_1_NOOPEN;
10037                     }
10038                   if (val & DF_1_ORIGIN)
10039                     {
10040                       printf (" ORIGIN");
10041                       val ^= DF_1_ORIGIN;
10042                     }
10043                   if (val & DF_1_DIRECT)
10044                     {
10045                       printf (" DIRECT");
10046                       val ^= DF_1_DIRECT;
10047                     }
10048                   if (val & DF_1_TRANS)
10049                     {
10050                       printf (" TRANS");
10051                       val ^= DF_1_TRANS;
10052                     }
10053                   if (val & DF_1_INTERPOSE)
10054                     {
10055                       printf (" INTERPOSE");
10056                       val ^= DF_1_INTERPOSE;
10057                     }
10058                   if (val & DF_1_NODEFLIB)
10059                     {
10060                       printf (" NODEFLIB");
10061                       val ^= DF_1_NODEFLIB;
10062                     }
10063                   if (val & DF_1_NODUMP)
10064                     {
10065                       printf (" NODUMP");
10066                       val ^= DF_1_NODUMP;
10067                     }
10068                   if (val & DF_1_CONFALT)
10069                     {
10070                       printf (" CONFALT");
10071                       val ^= DF_1_CONFALT;
10072                     }
10073                   if (val & DF_1_ENDFILTEE)
10074                     {
10075                       printf (" ENDFILTEE");
10076                       val ^= DF_1_ENDFILTEE;
10077                     }
10078                   if (val & DF_1_DISPRELDNE)
10079                     {
10080                       printf (" DISPRELDNE");
10081                       val ^= DF_1_DISPRELDNE;
10082                     }
10083                   if (val & DF_1_DISPRELPND)
10084                     {
10085                       printf (" DISPRELPND");
10086                       val ^= DF_1_DISPRELPND;
10087                     }
10088                   if (val & DF_1_NODIRECT)
10089                     {
10090                       printf (" NODIRECT");
10091                       val ^= DF_1_NODIRECT;
10092                     }
10093                   if (val & DF_1_IGNMULDEF)
10094                     {
10095                       printf (" IGNMULDEF");
10096                       val ^= DF_1_IGNMULDEF;
10097                     }
10098                   if (val & DF_1_NOKSYMS)
10099                     {
10100                       printf (" NOKSYMS");
10101                       val ^= DF_1_NOKSYMS;
10102                     }
10103                   if (val & DF_1_NOHDR)
10104                     {
10105                       printf (" NOHDR");
10106                       val ^= DF_1_NOHDR;
10107                     }
10108                   if (val & DF_1_EDITED)
10109                     {
10110                       printf (" EDITED");
10111                       val ^= DF_1_EDITED;
10112                     }
10113                   if (val & DF_1_NORELOC)
10114                     {
10115                       printf (" NORELOC");
10116                       val ^= DF_1_NORELOC;
10117                     }
10118                   if (val & DF_1_SYMINTPOSE)
10119                     {
10120                       printf (" SYMINTPOSE");
10121                       val ^= DF_1_SYMINTPOSE;
10122                     }
10123                   if (val & DF_1_GLOBAUDIT)
10124                     {
10125                       printf (" GLOBAUDIT");
10126                       val ^= DF_1_GLOBAUDIT;
10127                     }
10128                   if (val & DF_1_SINGLETON)
10129                     {
10130                       printf (" SINGLETON");
10131                       val ^= DF_1_SINGLETON;
10132                     }
10133                   if (val & DF_1_STUB)
10134                     {
10135                       printf (" STUB");
10136                       val ^= DF_1_STUB;
10137                     }
10138                   if (val & DF_1_PIE)
10139                     {
10140                       printf (" PIE");
10141                       val ^= DF_1_PIE;
10142                     }
10143                   if (val & DF_1_KMOD)
10144                     {
10145                       printf (" KMOD");
10146                       val ^= DF_1_KMOD;
10147                     }
10148                   if (val & DF_1_WEAKFILTER)
10149                     {
10150                       printf (" WEAKFILTER");
10151                       val ^= DF_1_WEAKFILTER;
10152                     }
10153                   if (val & DF_1_NOCOMMON)
10154                     {
10155                       printf (" NOCOMMON");
10156                       val ^= DF_1_NOCOMMON;
10157                     }
10158                   if (val != 0)
10159                     printf (" %lx", val);
10160                   puts ("");
10161                 }
10162             }
10163           break;
10164
10165         case DT_PLTREL:
10166           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10167           if (do_dynamic)
10168             puts (get_dynamic_type (filedata, entry->d_un.d_val));
10169           break;
10170
10171         case DT_NULL    :
10172         case DT_NEEDED  :
10173         case DT_PLTGOT  :
10174         case DT_HASH    :
10175         case DT_STRTAB  :
10176         case DT_SYMTAB  :
10177         case DT_RELA    :
10178         case DT_INIT    :
10179         case DT_FINI    :
10180         case DT_SONAME  :
10181         case DT_RPATH   :
10182         case DT_SYMBOLIC:
10183         case DT_REL     :
10184         case DT_DEBUG   :
10185         case DT_TEXTREL :
10186         case DT_JMPREL  :
10187         case DT_RUNPATH :
10188           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10189
10190           if (do_dynamic)
10191             {
10192               char * name;
10193
10194               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10195                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10196               else
10197                 name = NULL;
10198
10199               if (name)
10200                 {
10201                   switch (entry->d_tag)
10202                     {
10203                     case DT_NEEDED:
10204                       printf (_("Shared library: [%s]"), name);
10205
10206                       if (streq (name, program_interpreter))
10207                         printf (_(" program interpreter"));
10208                       break;
10209
10210                     case DT_SONAME:
10211                       printf (_("Library soname: [%s]"), name);
10212                       break;
10213
10214                     case DT_RPATH:
10215                       printf (_("Library rpath: [%s]"), name);
10216                       break;
10217
10218                     case DT_RUNPATH:
10219                       printf (_("Library runpath: [%s]"), name);
10220                       break;
10221
10222                     default:
10223                       print_vma (entry->d_un.d_val, PREFIX_HEX);
10224                       break;
10225                     }
10226                 }
10227               else
10228                 print_vma (entry->d_un.d_val, PREFIX_HEX);
10229
10230               putchar ('\n');
10231             }
10232           break;
10233
10234         case DT_PLTRELSZ:
10235         case DT_RELASZ  :
10236         case DT_STRSZ   :
10237         case DT_RELSZ   :
10238         case DT_RELAENT :
10239         case DT_SYMENT  :
10240         case DT_RELENT  :
10241           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10242           /* Fall through.  */
10243         case DT_PLTPADSZ:
10244         case DT_MOVEENT :
10245         case DT_MOVESZ  :
10246         case DT_INIT_ARRAYSZ:
10247         case DT_FINI_ARRAYSZ:
10248         case DT_GNU_CONFLICTSZ:
10249         case DT_GNU_LIBLISTSZ:
10250           if (do_dynamic)
10251             {
10252               print_vma (entry->d_un.d_val, UNSIGNED);
10253               printf (_(" (bytes)\n"));
10254             }
10255           break;
10256
10257         case DT_VERDEFNUM:
10258         case DT_VERNEEDNUM:
10259         case DT_RELACOUNT:
10260         case DT_RELCOUNT:
10261           if (do_dynamic)
10262             {
10263               print_vma (entry->d_un.d_val, UNSIGNED);
10264               putchar ('\n');
10265             }
10266           break;
10267
10268         case DT_SYMINSZ:
10269         case DT_SYMINENT:
10270         case DT_SYMINFO:
10271         case DT_USED:
10272         case DT_INIT_ARRAY:
10273         case DT_FINI_ARRAY:
10274           if (do_dynamic)
10275             {
10276               if (entry->d_tag == DT_USED
10277                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10278                 {
10279                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10280
10281                   if (*name)
10282                     {
10283                       printf (_("Not needed object: [%s]\n"), name);
10284                       break;
10285                     }
10286                 }
10287
10288               print_vma (entry->d_un.d_val, PREFIX_HEX);
10289               putchar ('\n');
10290             }
10291           break;
10292
10293         case DT_BIND_NOW:
10294           /* The value of this entry is ignored.  */
10295           if (do_dynamic)
10296             putchar ('\n');
10297           break;
10298
10299         case DT_GNU_PRELINKED:
10300           if (do_dynamic)
10301             {
10302               struct tm * tmp;
10303               time_t atime = entry->d_un.d_val;
10304
10305               tmp = gmtime (&atime);
10306               /* PR 17533 file: 041-1244816-0.004.  */
10307               if (tmp == NULL)
10308                 printf (_("<corrupt time val: %lx"),
10309                         (unsigned long) atime);
10310               else
10311                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10312                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10313                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10314
10315             }
10316           break;
10317
10318         case DT_GNU_HASH:
10319           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10320           if (do_dynamic)
10321             {
10322               print_vma (entry->d_un.d_val, PREFIX_HEX);
10323               putchar ('\n');
10324             }
10325           break;
10326
10327         default:
10328           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10329             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10330               entry->d_un.d_val;
10331
10332           if (do_dynamic)
10333             {
10334               switch (filedata->file_header.e_machine)
10335                 {
10336                 case EM_MIPS:
10337                 case EM_MIPS_RS3_LE:
10338                   dynamic_section_mips_val (entry);
10339                   break;
10340                 case EM_PARISC:
10341                   dynamic_section_parisc_val (entry);
10342                   break;
10343                 case EM_IA_64:
10344                   dynamic_section_ia64_val (entry);
10345                   break;
10346                 default:
10347                   print_vma (entry->d_un.d_val, PREFIX_HEX);
10348                   putchar ('\n');
10349                 }
10350             }
10351           break;
10352         }
10353     }
10354
10355   return TRUE;
10356 }
10357
10358 static char *
10359 get_ver_flags (unsigned int flags)
10360 {
10361   static char buff[128];
10362
10363   buff[0] = 0;
10364
10365   if (flags == 0)
10366     return _("none");
10367
10368   if (flags & VER_FLG_BASE)
10369     strcat (buff, "BASE");
10370
10371   if (flags & VER_FLG_WEAK)
10372     {
10373       if (flags & VER_FLG_BASE)
10374         strcat (buff, " | ");
10375
10376       strcat (buff, "WEAK");
10377     }
10378
10379   if (flags & VER_FLG_INFO)
10380     {
10381       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10382         strcat (buff, " | ");
10383
10384       strcat (buff, "INFO");
10385     }
10386
10387   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10388     {
10389       if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10390         strcat (buff, " | ");
10391
10392       strcat (buff, _("<unknown>"));
10393     }
10394
10395   return buff;
10396 }
10397
10398 /* Display the contents of the version sections.  */
10399
10400 static bfd_boolean
10401 process_version_sections (Filedata * filedata)
10402 {
10403   Elf_Internal_Shdr * section;
10404   unsigned i;
10405   bfd_boolean found = FALSE;
10406
10407   if (! do_version)
10408     return TRUE;
10409
10410   for (i = 0, section = filedata->section_headers;
10411        i < filedata->file_header.e_shnum;
10412        i++, section++)
10413     {
10414       switch (section->sh_type)
10415         {
10416         case SHT_GNU_verdef:
10417           {
10418             Elf_External_Verdef * edefs;
10419             unsigned long idx;
10420             unsigned long cnt;
10421             char * endbuf;
10422
10423             found = TRUE;
10424
10425             printf (ngettext ("\nVersion definition section '%s' "
10426                               "contains %u entry:\n",
10427                               "\nVersion definition section '%s' "
10428                               "contains %u entries:\n",
10429                               section->sh_info),
10430                     printable_section_name (filedata, section),
10431                     section->sh_info);
10432
10433             printf (_("  Addr: 0x"));
10434             printf_vma (section->sh_addr);
10435             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10436                     (unsigned long) section->sh_offset, section->sh_link,
10437                     printable_section_name_from_index (filedata, section->sh_link));
10438
10439             edefs = (Elf_External_Verdef *)
10440                 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
10441                           _("version definition section"));
10442             if (!edefs)
10443               break;
10444             endbuf = (char *) edefs + section->sh_size;
10445
10446             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10447               {
10448                 char * vstart;
10449                 Elf_External_Verdef * edef;
10450                 Elf_Internal_Verdef ent;
10451                 Elf_External_Verdaux * eaux;
10452                 Elf_Internal_Verdaux aux;
10453                 unsigned long isum;
10454                 int j;
10455
10456                 vstart = ((char *) edefs) + idx;
10457                 if (vstart + sizeof (*edef) > endbuf)
10458                   break;
10459
10460                 edef = (Elf_External_Verdef *) vstart;
10461
10462                 ent.vd_version = BYTE_GET (edef->vd_version);
10463                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
10464                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
10465                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
10466                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
10467                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
10468                 ent.vd_next    = BYTE_GET (edef->vd_next);
10469
10470                 printf (_("  %#06lx: Rev: %d  Flags: %s"),
10471                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10472
10473                 printf (_("  Index: %d  Cnt: %d  "),
10474                         ent.vd_ndx, ent.vd_cnt);
10475
10476                 /* Check for overflow.  */
10477                 if (ent.vd_aux > (size_t) (endbuf - vstart))
10478                   break;
10479
10480                 vstart += ent.vd_aux;
10481
10482                 if (vstart + sizeof (*eaux) > endbuf)
10483                   break;
10484                 eaux = (Elf_External_Verdaux *) vstart;
10485
10486                 aux.vda_name = BYTE_GET (eaux->vda_name);
10487                 aux.vda_next = BYTE_GET (eaux->vda_next);
10488
10489                 if (VALID_DYNAMIC_NAME (aux.vda_name))
10490                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10491                 else
10492                   printf (_("Name index: %ld\n"), aux.vda_name);
10493
10494                 isum = idx + ent.vd_aux;
10495
10496                 for (j = 1; j < ent.vd_cnt; j++)
10497                   {
10498                     if (aux.vda_next < sizeof (*eaux)
10499                         && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10500                       {
10501                         warn (_("Invalid vda_next field of %lx\n"),
10502                               aux.vda_next);
10503                         j = ent.vd_cnt;
10504                         break;
10505                       }
10506                     /* Check for overflow.  */
10507                     if (aux.vda_next > (size_t) (endbuf - vstart))
10508                       break;
10509
10510                     isum   += aux.vda_next;
10511                     vstart += aux.vda_next;
10512
10513                     if (vstart + sizeof (*eaux) > endbuf)
10514                       break;
10515                     eaux = (Elf_External_Verdaux *) vstart;
10516
10517                     aux.vda_name = BYTE_GET (eaux->vda_name);
10518                     aux.vda_next = BYTE_GET (eaux->vda_next);
10519
10520                     if (VALID_DYNAMIC_NAME (aux.vda_name))
10521                       printf (_("  %#06lx: Parent %d: %s\n"),
10522                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10523                     else
10524                       printf (_("  %#06lx: Parent %d, name index: %ld\n"),
10525                               isum, j, aux.vda_name);
10526                   }
10527
10528                 if (j < ent.vd_cnt)
10529                   printf (_("  Version def aux past end of section\n"));
10530
10531                 /* PR 17531:
10532                    file: id:000001,src:000172+005151,op:splice,rep:2.  */
10533                 if (ent.vd_next < sizeof (*edef)
10534                     && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10535                   {
10536                     warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10537                     cnt = section->sh_info;
10538                     break;
10539                   }
10540                 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10541                   break;
10542
10543                 idx += ent.vd_next;
10544               }
10545
10546             if (cnt < section->sh_info)
10547               printf (_("  Version definition past end of section\n"));
10548
10549             free (edefs);
10550           }
10551           break;
10552
10553         case SHT_GNU_verneed:
10554           {
10555             Elf_External_Verneed * eneed;
10556             unsigned long idx;
10557             unsigned long cnt;
10558             char * endbuf;
10559
10560             found = TRUE;
10561
10562             printf (ngettext ("\nVersion needs section '%s' "
10563                               "contains %u entry:\n",
10564                               "\nVersion needs section '%s' "
10565                               "contains %u entries:\n",
10566                               section->sh_info),
10567                     printable_section_name (filedata, section), section->sh_info);
10568
10569             printf (_(" Addr: 0x"));
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_from_index (filedata, section->sh_link));
10574
10575             eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
10576                                                        section->sh_offset, 1,
10577                                                        section->sh_size,
10578                                                        _("Version Needs section"));
10579             if (!eneed)
10580               break;
10581             endbuf = (char *) eneed + section->sh_size;
10582
10583             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10584               {
10585                 Elf_External_Verneed * entry;
10586                 Elf_Internal_Verneed ent;
10587                 unsigned long isum;
10588                 int j;
10589                 char * vstart;
10590
10591                 vstart = ((char *) eneed) + idx;
10592                 if (vstart + sizeof (*entry) > endbuf)
10593                   break;
10594
10595                 entry = (Elf_External_Verneed *) vstart;
10596
10597                 ent.vn_version = BYTE_GET (entry->vn_version);
10598                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
10599                 ent.vn_file    = BYTE_GET (entry->vn_file);
10600                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
10601                 ent.vn_next    = BYTE_GET (entry->vn_next);
10602
10603                 printf (_("  %#06lx: Version: %d"), idx, ent.vn_version);
10604
10605                 if (VALID_DYNAMIC_NAME (ent.vn_file))
10606                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10607                 else
10608                   printf (_("  File: %lx"), ent.vn_file);
10609
10610                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
10611
10612                 /* Check for overflow.  */
10613                 if (ent.vn_aux > (size_t) (endbuf - vstart))
10614                   break;
10615                 vstart += ent.vn_aux;
10616
10617                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10618                   {
10619                     Elf_External_Vernaux * eaux;
10620                     Elf_Internal_Vernaux aux;
10621
10622                     if (vstart + sizeof (*eaux) > endbuf)
10623                       break;
10624                     eaux = (Elf_External_Vernaux *) vstart;
10625
10626                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
10627                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
10628                     aux.vna_other = BYTE_GET (eaux->vna_other);
10629                     aux.vna_name  = BYTE_GET (eaux->vna_name);
10630                     aux.vna_next  = BYTE_GET (eaux->vna_next);
10631
10632                     if (VALID_DYNAMIC_NAME (aux.vna_name))
10633                       printf (_("  %#06lx:   Name: %s"),
10634                               isum, GET_DYNAMIC_NAME (aux.vna_name));
10635                     else
10636                       printf (_("  %#06lx:   Name index: %lx"),
10637                               isum, aux.vna_name);
10638
10639                     printf (_("  Flags: %s  Version: %d\n"),
10640                             get_ver_flags (aux.vna_flags), aux.vna_other);
10641
10642                     if (aux.vna_next < sizeof (*eaux)
10643                         && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10644                       {
10645                         warn (_("Invalid vna_next field of %lx\n"),
10646                               aux.vna_next);
10647                         j = ent.vn_cnt;
10648                         break;
10649                       }
10650                     /* Check for overflow.  */
10651                     if (aux.vna_next > (size_t) (endbuf - vstart))
10652                       break;
10653                     isum   += aux.vna_next;
10654                     vstart += aux.vna_next;
10655                   }
10656
10657                 if (j < ent.vn_cnt)
10658                   warn (_("Missing Version Needs auxillary information\n"));
10659
10660                 if (ent.vn_next < sizeof (*entry)
10661                     && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10662                   {
10663                     warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10664                     cnt = section->sh_info;
10665                     break;
10666                   }
10667                 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10668                   break;
10669                 idx += ent.vn_next;
10670               }
10671
10672             if (cnt < section->sh_info)
10673               warn (_("Missing Version Needs information\n"));
10674
10675             free (eneed);
10676           }
10677           break;
10678
10679         case SHT_GNU_versym:
10680           {
10681             Elf_Internal_Shdr * link_section;
10682             size_t total;
10683             unsigned int cnt;
10684             unsigned char * edata;
10685             unsigned short * data;
10686             char * strtab;
10687             Elf_Internal_Sym * symbols;
10688             Elf_Internal_Shdr * string_sec;
10689             unsigned long num_syms;
10690             long off;
10691
10692             if (section->sh_link >= filedata->file_header.e_shnum)
10693               break;
10694
10695             link_section = filedata->section_headers + section->sh_link;
10696             total = section->sh_size / sizeof (Elf_External_Versym);
10697
10698             if (link_section->sh_link >= filedata->file_header.e_shnum)
10699               break;
10700
10701             found = TRUE;
10702
10703             symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
10704             if (symbols == NULL)
10705               break;
10706
10707             string_sec = filedata->section_headers + link_section->sh_link;
10708
10709             strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
10710                                         string_sec->sh_size,
10711                                         _("version string table"));
10712             if (!strtab)
10713               {
10714                 free (symbols);
10715                 break;
10716               }
10717
10718             printf (ngettext ("\nVersion symbols section '%s' "
10719                               "contains %lu entry:\n",
10720                               "\nVersion symbols section '%s' "
10721                               "contains %lu entries:\n",
10722                               total),
10723                     printable_section_name (filedata, section), (unsigned long) total);
10724
10725             printf (_(" Addr: "));
10726             printf_vma (section->sh_addr);
10727             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10728                     (unsigned long) section->sh_offset, section->sh_link,
10729                     printable_section_name (filedata, link_section));
10730
10731             off = offset_from_vma (filedata,
10732                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10733                                    total * sizeof (short));
10734             edata = (unsigned char *) get_data (NULL, filedata, off, total,
10735                                                 sizeof (short),
10736                                                 _("version symbol data"));
10737             if (!edata)
10738               {
10739                 free (strtab);
10740                 free (symbols);
10741                 break;
10742               }
10743
10744             data = (short unsigned int *) cmalloc (total, sizeof (short));
10745
10746             for (cnt = total; cnt --;)
10747               data[cnt] = byte_get (edata + cnt * sizeof (short),
10748                                     sizeof (short));
10749
10750             free (edata);
10751
10752             for (cnt = 0; cnt < total; cnt += 4)
10753               {
10754                 int j, nn;
10755                 char *name;
10756                 char *invalid = _("*invalid*");
10757
10758                 printf ("  %03x:", cnt);
10759
10760                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10761                   switch (data[cnt + j])
10762                     {
10763                     case 0:
10764                       fputs (_("   0 (*local*)    "), stdout);
10765                       break;
10766
10767                     case 1:
10768                       fputs (_("   1 (*global*)   "), stdout);
10769                       break;
10770
10771                     default:
10772                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10773                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10774
10775                       /* If this index value is greater than the size of the symbols
10776                          array, break to avoid an out-of-bounds read.  */
10777                       if ((unsigned long)(cnt + j) >= num_syms)
10778                         {
10779                           warn (_("invalid index into symbol array\n"));
10780                           break;
10781                         }
10782
10783                       name = NULL;
10784                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10785                         {
10786                           Elf_Internal_Verneed ivn;
10787                           unsigned long offset;
10788
10789                           offset = offset_from_vma
10790                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10791                              sizeof (Elf_External_Verneed));
10792
10793                           do
10794                             {
10795                               Elf_Internal_Vernaux ivna;
10796                               Elf_External_Verneed evn;
10797                               Elf_External_Vernaux evna;
10798                               unsigned long a_off;
10799
10800                               if (get_data (&evn, filedata, offset, sizeof (evn), 1,
10801                                             _("version need")) == NULL)
10802                                 break;
10803
10804                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10805                               ivn.vn_next = BYTE_GET (evn.vn_next);
10806
10807                               a_off = offset + ivn.vn_aux;
10808
10809                               do
10810                                 {
10811                                   if (get_data (&evna, filedata, a_off, sizeof (evna),
10812                                                 1, _("version need aux (2)")) == NULL)
10813                                     {
10814                                       ivna.vna_next  = 0;
10815                                       ivna.vna_other = 0;
10816                                     }
10817                                   else
10818                                     {
10819                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
10820                                       ivna.vna_other = BYTE_GET (evna.vna_other);
10821                                     }
10822
10823                                   a_off += ivna.vna_next;
10824                                 }
10825                               while (ivna.vna_other != data[cnt + j]
10826                                      && ivna.vna_next != 0);
10827
10828                               if (ivna.vna_other == data[cnt + j])
10829                                 {
10830                                   ivna.vna_name = BYTE_GET (evna.vna_name);
10831
10832                                   if (ivna.vna_name >= string_sec->sh_size)
10833                                     name = invalid;
10834                                   else
10835                                     name = strtab + ivna.vna_name;
10836                                   break;
10837                                 }
10838
10839                               offset += ivn.vn_next;
10840                             }
10841                           while (ivn.vn_next);
10842                         }
10843
10844                       if (data[cnt + j] != 0x8001
10845                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10846                         {
10847                           Elf_Internal_Verdef ivd;
10848                           Elf_External_Verdef evd;
10849                           unsigned long offset;
10850
10851                           offset = offset_from_vma
10852                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10853                              sizeof evd);
10854
10855                           do
10856                             {
10857                               if (get_data (&evd, filedata, offset, sizeof (evd), 1,
10858                                             _("version def")) == NULL)
10859                                 {
10860                                   ivd.vd_next = 0;
10861                                   /* PR 17531: file: 046-1082287-0.004.  */
10862                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
10863                                   break;
10864                                 }
10865                               else
10866                                 {
10867                                   ivd.vd_next = BYTE_GET (evd.vd_next);
10868                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
10869                                 }
10870
10871                               offset += ivd.vd_next;
10872                             }
10873                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10874                                  && ivd.vd_next != 0);
10875
10876                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10877                             {
10878                               Elf_External_Verdaux evda;
10879                               Elf_Internal_Verdaux ivda;
10880
10881                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
10882
10883                               if (get_data (&evda, filedata,
10884                                             offset - ivd.vd_next + ivd.vd_aux,
10885                                             sizeof (evda), 1,
10886                                             _("version def aux")) == NULL)
10887                                 break;
10888
10889                               ivda.vda_name = BYTE_GET (evda.vda_name);
10890
10891                               if (ivda.vda_name >= string_sec->sh_size)
10892                                 name = invalid;
10893                               else if (name != NULL && name != invalid)
10894                                 name = _("*both*");
10895                               else
10896                                 name = strtab + ivda.vda_name;
10897                             }
10898                         }
10899                       if (name != NULL)
10900                         nn += printf ("(%s%-*s",
10901                                       name,
10902                                       12 - (int) strlen (name),
10903                                       ")");
10904
10905                       if (nn < 18)
10906                         printf ("%*c", 18 - nn, ' ');
10907                     }
10908
10909                 putchar ('\n');
10910               }
10911
10912             free (data);
10913             free (strtab);
10914             free (symbols);
10915           }
10916           break;
10917
10918         default:
10919           break;
10920         }
10921     }
10922
10923   if (! found)
10924     printf (_("\nNo version information found in this file.\n"));
10925
10926   return TRUE;
10927 }
10928
10929 static const char *
10930 get_symbol_binding (Filedata * filedata, unsigned int binding)
10931 {
10932   static char buff[32];
10933
10934   switch (binding)
10935     {
10936     case STB_LOCAL:     return "LOCAL";
10937     case STB_GLOBAL:    return "GLOBAL";
10938     case STB_WEAK:      return "WEAK";
10939     default:
10940       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10941         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10942                   binding);
10943       else if (binding >= STB_LOOS && binding <= STB_HIOS)
10944         {
10945           if (binding == STB_GNU_UNIQUE
10946               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10947                   /* GNU is still using the default value 0.  */
10948                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10949             return "UNIQUE";
10950           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10951         }
10952       else
10953         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10954       return buff;
10955     }
10956 }
10957
10958 static const char *
10959 get_symbol_type (Filedata * filedata, unsigned int type)
10960 {
10961   static char buff[32];
10962
10963   switch (type)
10964     {
10965     case STT_NOTYPE:    return "NOTYPE";
10966     case STT_OBJECT:    return "OBJECT";
10967     case STT_FUNC:      return "FUNC";
10968     case STT_SECTION:   return "SECTION";
10969     case STT_FILE:      return "FILE";
10970     case STT_COMMON:    return "COMMON";
10971     case STT_TLS:       return "TLS";
10972     case STT_RELC:      return "RELC";
10973     case STT_SRELC:     return "SRELC";
10974     default:
10975       if (type >= STT_LOPROC && type <= STT_HIPROC)
10976         {
10977           if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10978             return "THUMB_FUNC";
10979
10980           if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10981             return "REGISTER";
10982
10983           if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10984             return "PARISC_MILLI";
10985
10986           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10987         }
10988       else if (type >= STT_LOOS && type <= STT_HIOS)
10989         {
10990           if (filedata->file_header.e_machine == EM_PARISC)
10991             {
10992               if (type == STT_HP_OPAQUE)
10993                 return "HP_OPAQUE";
10994               if (type == STT_HP_STUB)
10995                 return "HP_STUB";
10996             }
10997
10998           if (type == STT_GNU_IFUNC
10999               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
11000                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
11001                   /* GNU is still using the default value 0.  */
11002                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
11003             return "IFUNC";
11004
11005           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
11006         }
11007       else
11008         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
11009       return buff;
11010     }
11011 }
11012
11013 static const char *
11014 get_symbol_visibility (unsigned int visibility)
11015 {
11016   switch (visibility)
11017     {
11018     case STV_DEFAULT:   return "DEFAULT";
11019     case STV_INTERNAL:  return "INTERNAL";
11020     case STV_HIDDEN:    return "HIDDEN";
11021     case STV_PROTECTED: return "PROTECTED";
11022     default:
11023       error (_("Unrecognized visibility value: %u"), visibility);
11024       return _("<unknown>");
11025     }
11026 }
11027
11028 static const char *
11029 get_solaris_symbol_visibility (unsigned int visibility)
11030 {
11031   switch (visibility)
11032     {
11033     case 4: return "EXPORTED";
11034     case 5: return "SINGLETON";
11035     case 6: return "ELIMINATE";
11036     default: return get_symbol_visibility (visibility);
11037     }
11038 }
11039
11040 static const char *
11041 get_mips_symbol_other (unsigned int other)
11042 {
11043   switch (other)
11044     {
11045     case STO_OPTIONAL:      return "OPTIONAL";
11046     case STO_MIPS_PLT:      return "MIPS PLT";
11047     case STO_MIPS_PIC:      return "MIPS PIC";
11048     case STO_MICROMIPS:     return "MICROMIPS";
11049     case STO_MICROMIPS | STO_MIPS_PIC:      return "MICROMIPS, MIPS PIC";
11050     case STO_MIPS16:        return "MIPS16";
11051     default:                return NULL;
11052     }
11053 }
11054
11055 static const char *
11056 get_ia64_symbol_other (Filedata * filedata, unsigned int other)
11057 {
11058   if (is_ia64_vms (filedata))
11059     {
11060       static char res[32];
11061
11062       res[0] = 0;
11063
11064       /* Function types is for images and .STB files only.  */
11065       switch (filedata->file_header.e_type)
11066         {
11067         case ET_DYN:
11068         case ET_EXEC:
11069           switch (VMS_ST_FUNC_TYPE (other))
11070             {
11071             case VMS_SFT_CODE_ADDR:
11072               strcat (res, " CA");
11073               break;
11074             case VMS_SFT_SYMV_IDX:
11075               strcat (res, " VEC");
11076               break;
11077             case VMS_SFT_FD:
11078               strcat (res, " FD");
11079               break;
11080             case VMS_SFT_RESERVE:
11081               strcat (res, " RSV");
11082               break;
11083             default:
11084               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11085                     VMS_ST_FUNC_TYPE (other));
11086               strcat (res, " <unknown>");
11087               break;
11088             }
11089           break;
11090         default:
11091           break;
11092         }
11093       switch (VMS_ST_LINKAGE (other))
11094         {
11095         case VMS_STL_IGNORE:
11096           strcat (res, " IGN");
11097           break;
11098         case VMS_STL_RESERVE:
11099           strcat (res, " RSV");
11100           break;
11101         case VMS_STL_STD:
11102           strcat (res, " STD");
11103           break;
11104         case VMS_STL_LNK:
11105           strcat (res, " LNK");
11106           break;
11107         default:
11108           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11109                 VMS_ST_LINKAGE (other));
11110           strcat (res, " <unknown>");
11111           break;
11112         }
11113
11114       if (res[0] != 0)
11115         return res + 1;
11116       else
11117         return res;
11118     }
11119   return NULL;
11120 }
11121
11122 static const char *
11123 get_ppc64_symbol_other (unsigned int other)
11124 {
11125   if ((other & ~STO_PPC64_LOCAL_MASK) != 0)
11126     return NULL;
11127
11128   other >>= STO_PPC64_LOCAL_BIT;
11129   if (other <= 6)
11130     {
11131       static char buf[32];
11132       if (other >= 2)
11133         other = ppc64_decode_local_entry (other);
11134       snprintf (buf, sizeof buf, _("<localentry>: %d"), other);
11135       return buf;
11136     }
11137   return NULL;
11138 }
11139
11140 static const char *
11141 get_symbol_other (Filedata * filedata, unsigned int other)
11142 {
11143   const char * result = NULL;
11144   static char buff [32];
11145
11146   if (other == 0)
11147     return "";
11148
11149   switch (filedata->file_header.e_machine)
11150     {
11151     case EM_MIPS:
11152       result = get_mips_symbol_other (other);
11153       break;
11154     case EM_IA_64:
11155       result = get_ia64_symbol_other (filedata, other);
11156       break;
11157     case EM_PPC64:
11158       result = get_ppc64_symbol_other (other);
11159       break;
11160     default:
11161       result = NULL;
11162       break;
11163     }
11164
11165   if (result)
11166     return result;
11167
11168   snprintf (buff, sizeof buff, _("<other>: %x"), other);
11169   return buff;
11170 }
11171
11172 static const char *
11173 get_symbol_index_type (Filedata * filedata, unsigned int type)
11174 {
11175   static char buff[32];
11176
11177   switch (type)
11178     {
11179     case SHN_UNDEF:     return "UND";
11180     case SHN_ABS:       return "ABS";
11181     case SHN_COMMON:    return "COM";
11182     default:
11183       if (type == SHN_IA_64_ANSI_COMMON
11184           && filedata->file_header.e_machine == EM_IA_64
11185           && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11186         return "ANSI_COM";
11187       else if ((filedata->file_header.e_machine == EM_X86_64
11188                 || filedata->file_header.e_machine == EM_L1OM
11189                 || filedata->file_header.e_machine == EM_K1OM)
11190                && type == SHN_X86_64_LCOMMON)
11191         return "LARGE_COM";
11192       else if ((type == SHN_MIPS_SCOMMON
11193                 && filedata->file_header.e_machine == EM_MIPS)
11194                || (type == SHN_TIC6X_SCOMMON
11195                    && filedata->file_header.e_machine == EM_TI_C6000))
11196         return "SCOM";
11197       else if (type == SHN_MIPS_SUNDEFINED
11198                && filedata->file_header.e_machine == EM_MIPS)
11199         return "SUND";
11200       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11201         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11202       else if (type >= SHN_LOOS && type <= SHN_HIOS)
11203         sprintf (buff, "OS [0x%04x]", type & 0xffff);
11204       else if (type >= SHN_LORESERVE)
11205         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11206       else if (type >= filedata->file_header.e_shnum)
11207         sprintf (buff, _("bad section index[%3d]"), type);
11208       else
11209         sprintf (buff, "%3d", type);
11210       break;
11211     }
11212
11213   return buff;
11214 }
11215
11216 static bfd_vma *
11217 get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
11218 {
11219   unsigned char * e_data;
11220   bfd_vma * i_data;
11221
11222   /* If the size_t type is smaller than the bfd_size_type, eg because
11223      you are building a 32-bit tool on a 64-bit host, then make sure
11224      that when (number) is cast to (size_t) no information is lost.  */
11225   if (sizeof (size_t) < sizeof (bfd_size_type)
11226       && (bfd_size_type) ((size_t) number) != number)
11227     {
11228       error (_("Size truncation prevents reading %s elements of size %u\n"),
11229              bfd_vmatoa ("u", number), ent_size);
11230       return NULL;
11231     }
11232
11233   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11234      attempting to allocate memory when the read is bound to fail.  */
11235   if (ent_size * number > filedata->file_size)
11236     {
11237       error (_("Invalid number of dynamic entries: %s\n"),
11238              bfd_vmatoa ("u", number));
11239       return NULL;
11240     }
11241
11242   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11243   if (e_data == NULL)
11244     {
11245       error (_("Out of memory reading %s dynamic entries\n"),
11246              bfd_vmatoa ("u", number));
11247       return NULL;
11248     }
11249
11250   if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
11251     {
11252       error (_("Unable to read in %s bytes of dynamic data\n"),
11253              bfd_vmatoa ("u", number * ent_size));
11254       free (e_data);
11255       return NULL;
11256     }
11257
11258   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11259   if (i_data == NULL)
11260     {
11261       error (_("Out of memory allocating space for %s dynamic entries\n"),
11262              bfd_vmatoa ("u", number));
11263       free (e_data);
11264       return NULL;
11265     }
11266
11267   while (number--)
11268     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11269
11270   free (e_data);
11271
11272   return i_data;
11273 }
11274
11275 static void
11276 print_dynamic_symbol (Filedata * filedata, bfd_vma si, unsigned long hn)
11277 {
11278   Elf_Internal_Sym * psym;
11279   int n;
11280
11281   n = print_vma (si, DEC_5);
11282   if (n < 5)
11283     fputs (&"     "[n], stdout);
11284   printf (" %3lu: ", hn);
11285
11286   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11287     {
11288       printf (_("<No info available for dynamic symbol number %lu>\n"),
11289               (unsigned long) si);
11290       return;
11291     }
11292
11293   psym = dynamic_symbols + si;
11294   print_vma (psym->st_value, LONG_HEX);
11295   putchar (' ');
11296   print_vma (psym->st_size, DEC_5);
11297
11298   printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11299   printf (" %-6s",  get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11300
11301   if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11302     printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11303   else
11304     {
11305       unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11306
11307       printf (" %-7s",  get_symbol_visibility (vis));
11308       /* Check to see if any other bits in the st_other field are set.
11309          Note - displaying this information disrupts the layout of the
11310          table being generated, but for the moment this case is very
11311          rare.  */
11312       if (psym->st_other ^ vis)
11313         printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11314     }
11315
11316   printf (" %3.3s ", get_symbol_index_type (filedata, psym->st_shndx));
11317   if (VALID_DYNAMIC_NAME (psym->st_name))
11318     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11319   else
11320     printf (_(" <corrupt: %14ld>"), psym->st_name);
11321   putchar ('\n');
11322 }
11323
11324 static const char *
11325 get_symbol_version_string (Filedata *                   filedata,
11326                            bfd_boolean                  is_dynsym,
11327                            const char *                 strtab,
11328                            unsigned long int            strtab_size,
11329                            unsigned int                 si,
11330                            Elf_Internal_Sym *           psym,
11331                            enum versioned_symbol_info * sym_info,
11332                            unsigned short *             vna_other)
11333 {
11334   unsigned char data[2];
11335   unsigned short vers_data;
11336   unsigned long offset;
11337   unsigned short max_vd_ndx;
11338
11339   if (!is_dynsym
11340       || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11341     return NULL;
11342
11343   offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11344                             sizeof data + si * sizeof (vers_data));
11345
11346   if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11347                 sizeof (data), 1, _("version data")) == NULL)
11348     return NULL;
11349
11350   vers_data = byte_get (data, 2);
11351
11352   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data == 0)
11353     return NULL;
11354
11355   max_vd_ndx = 0;
11356
11357   /* Usually we'd only see verdef for defined symbols, and verneed for
11358      undefined symbols.  However, symbols defined by the linker in
11359      .dynbss for variables copied from a shared library in order to
11360      avoid text relocations are defined yet have verneed.  We could
11361      use a heuristic to detect the special case, for example, check
11362      for verneed first on symbols defined in SHT_NOBITS sections, but
11363      it is simpler and more reliable to just look for both verdef and
11364      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
11365
11366   if (psym->st_shndx != SHN_UNDEF
11367       && vers_data != 0x8001
11368       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11369     {
11370       Elf_Internal_Verdef ivd;
11371       Elf_Internal_Verdaux ivda;
11372       Elf_External_Verdaux evda;
11373       unsigned long off;
11374
11375       off = offset_from_vma (filedata,
11376                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11377                              sizeof (Elf_External_Verdef));
11378
11379       do
11380         {
11381           Elf_External_Verdef evd;
11382
11383           if (get_data (&evd, filedata, off, sizeof (evd), 1,
11384                         _("version def")) == NULL)
11385             {
11386               ivd.vd_ndx = 0;
11387               ivd.vd_aux = 0;
11388               ivd.vd_next = 0;
11389               ivd.vd_flags = 0;
11390             }
11391           else
11392             {
11393               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11394               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11395               ivd.vd_next = BYTE_GET (evd.vd_next);
11396               ivd.vd_flags = BYTE_GET (evd.vd_flags);
11397             }
11398
11399           if ((ivd.vd_ndx & VERSYM_VERSION) > max_vd_ndx)
11400             max_vd_ndx = ivd.vd_ndx & VERSYM_VERSION;
11401
11402           off += ivd.vd_next;
11403         }
11404       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11405
11406       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11407         {
11408           if (ivd.vd_ndx == 1 && ivd.vd_flags == VER_FLG_BASE)
11409             return NULL;
11410
11411           off -= ivd.vd_next;
11412           off += ivd.vd_aux;
11413
11414           if (get_data (&evda, filedata, off, sizeof (evda), 1,
11415                         _("version def aux")) != NULL)
11416             {
11417               ivda.vda_name = BYTE_GET (evda.vda_name);
11418
11419               if (psym->st_name != ivda.vda_name)
11420                 {
11421                   *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11422                                ? symbol_hidden : symbol_public);
11423                   return (ivda.vda_name < strtab_size
11424                           ? strtab + ivda.vda_name : _("<corrupt>"));
11425                 }
11426             }
11427         }
11428     }
11429
11430   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11431     {
11432       Elf_External_Verneed evn;
11433       Elf_Internal_Verneed ivn;
11434       Elf_Internal_Vernaux ivna;
11435
11436       offset = offset_from_vma (filedata,
11437                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11438                                 sizeof evn);
11439       do
11440         {
11441           unsigned long vna_off;
11442
11443           if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11444                         _("version need")) == NULL)
11445             {
11446               ivna.vna_next = 0;
11447               ivna.vna_other = 0;
11448               ivna.vna_name = 0;
11449               break;
11450             }
11451
11452           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
11453           ivn.vn_next = BYTE_GET (evn.vn_next);
11454
11455           vna_off = offset + ivn.vn_aux;
11456
11457           do
11458             {
11459               Elf_External_Vernaux evna;
11460
11461               if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11462                             _("version need aux (3)")) == NULL)
11463                 {
11464                   ivna.vna_next = 0;
11465                   ivna.vna_other = 0;
11466                   ivna.vna_name = 0;
11467                 }
11468               else
11469                 {
11470                   ivna.vna_other = BYTE_GET (evna.vna_other);
11471                   ivna.vna_next  = BYTE_GET (evna.vna_next);
11472                   ivna.vna_name  = BYTE_GET (evna.vna_name);
11473                 }
11474
11475               vna_off += ivna.vna_next;
11476             }
11477           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11478
11479           if (ivna.vna_other == vers_data)
11480             break;
11481
11482           offset += ivn.vn_next;
11483         }
11484       while (ivn.vn_next != 0);
11485
11486       if (ivna.vna_other == vers_data)
11487         {
11488           *sym_info = symbol_undefined;
11489           *vna_other = ivna.vna_other;
11490           return (ivna.vna_name < strtab_size
11491                   ? strtab + ivna.vna_name : _("<corrupt>"));
11492         }
11493       else if ((max_vd_ndx || (vers_data & VERSYM_VERSION) != 1)
11494                && (vers_data & VERSYM_VERSION) > max_vd_ndx)
11495         return _("<corrupt>");
11496     }
11497   return NULL;
11498 }
11499
11500 /* Dump the symbol table.  */
11501 static bfd_boolean
11502 process_symbol_table (Filedata * filedata)
11503 {
11504   Elf_Internal_Shdr * section;
11505   bfd_size_type nbuckets = 0;
11506   bfd_size_type nchains = 0;
11507   bfd_vma * buckets = NULL;
11508   bfd_vma * chains = NULL;
11509   bfd_vma ngnubuckets = 0;
11510   bfd_vma * gnubuckets = NULL;
11511   bfd_vma * gnuchains = NULL;
11512   bfd_vma gnusymidx = 0;
11513   bfd_size_type ngnuchains = 0;
11514
11515   if (!do_syms && !do_dyn_syms && !do_histogram)
11516     return TRUE;
11517
11518   if (dynamic_info[DT_HASH]
11519       && (do_histogram
11520           || (do_using_dynamic
11521               && !do_dyn_syms
11522               && dynamic_strings != NULL)))
11523     {
11524       unsigned char nb[8];
11525       unsigned char nc[8];
11526       unsigned int hash_ent_size = 4;
11527
11528       if ((filedata->file_header.e_machine == EM_ALPHA
11529            || filedata->file_header.e_machine == EM_S390
11530            || filedata->file_header.e_machine == EM_S390_OLD)
11531           && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11532         hash_ent_size = 8;
11533
11534       if (fseek (filedata->handle,
11535                  (archive_file_offset
11536                   + offset_from_vma (filedata, dynamic_info[DT_HASH],
11537                                      sizeof nb + sizeof nc)),
11538                  SEEK_SET))
11539         {
11540           error (_("Unable to seek to start of dynamic information\n"));
11541           goto no_hash;
11542         }
11543
11544       if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11545         {
11546           error (_("Failed to read in number of buckets\n"));
11547           goto no_hash;
11548         }
11549
11550       if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11551         {
11552           error (_("Failed to read in number of chains\n"));
11553           goto no_hash;
11554         }
11555
11556       nbuckets = byte_get (nb, hash_ent_size);
11557       nchains  = byte_get (nc, hash_ent_size);
11558
11559       buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11560       chains  = get_dynamic_data (filedata, nchains, hash_ent_size);
11561
11562     no_hash:
11563       if (buckets == NULL || chains == NULL)
11564         {
11565           if (do_using_dynamic)
11566             return FALSE;
11567           free (buckets);
11568           free (chains);
11569           buckets = NULL;
11570           chains = NULL;
11571           nbuckets = 0;
11572           nchains = 0;
11573         }
11574     }
11575
11576   if (dynamic_info_DT_GNU_HASH
11577       && (do_histogram
11578           || (do_using_dynamic
11579               && !do_dyn_syms
11580               && dynamic_strings != NULL)))
11581     {
11582       unsigned char nb[16];
11583       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11584       bfd_vma buckets_vma;
11585
11586       if (fseek (filedata->handle,
11587                  (archive_file_offset
11588                   + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11589                                      sizeof nb)),
11590                  SEEK_SET))
11591         {
11592           error (_("Unable to seek to start of dynamic information\n"));
11593           goto no_gnu_hash;
11594         }
11595
11596       if (fread (nb, 16, 1, filedata->handle) != 1)
11597         {
11598           error (_("Failed to read in number of buckets\n"));
11599           goto no_gnu_hash;
11600         }
11601
11602       ngnubuckets = byte_get (nb, 4);
11603       gnusymidx = byte_get (nb + 4, 4);
11604       bitmaskwords = byte_get (nb + 8, 4);
11605       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11606       if (is_32bit_elf)
11607         buckets_vma += bitmaskwords * 4;
11608       else
11609         buckets_vma += bitmaskwords * 8;
11610
11611       if (fseek (filedata->handle,
11612                  (archive_file_offset
11613                   + offset_from_vma (filedata, buckets_vma, 4)),
11614                  SEEK_SET))
11615         {
11616           error (_("Unable to seek to start of dynamic information\n"));
11617           goto no_gnu_hash;
11618         }
11619
11620       gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11621
11622       if (gnubuckets == NULL)
11623         goto no_gnu_hash;
11624
11625       for (i = 0; i < ngnubuckets; i++)
11626         if (gnubuckets[i] != 0)
11627           {
11628             if (gnubuckets[i] < gnusymidx)
11629               return FALSE;
11630
11631             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11632               maxchain = gnubuckets[i];
11633           }
11634
11635       if (maxchain == 0xffffffff)
11636         goto no_gnu_hash;
11637
11638       maxchain -= gnusymidx;
11639
11640       if (fseek (filedata->handle,
11641                  (archive_file_offset
11642                   + offset_from_vma (filedata, buckets_vma
11643                                            + 4 * (ngnubuckets + maxchain), 4)),
11644                  SEEK_SET))
11645         {
11646           error (_("Unable to seek to start of dynamic information\n"));
11647           goto no_gnu_hash;
11648         }
11649
11650       do
11651         {
11652           if (fread (nb, 4, 1, filedata->handle) != 1)
11653             {
11654               error (_("Failed to determine last chain length\n"));
11655               goto no_gnu_hash;
11656             }
11657
11658           if (maxchain + 1 == 0)
11659             goto no_gnu_hash;
11660
11661           ++maxchain;
11662         }
11663       while ((byte_get (nb, 4) & 1) == 0);
11664
11665       if (fseek (filedata->handle,
11666                  (archive_file_offset
11667                   + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11668                  SEEK_SET))
11669         {
11670           error (_("Unable to seek to start of dynamic information\n"));
11671           goto no_gnu_hash;
11672         }
11673
11674       gnuchains = get_dynamic_data (filedata, maxchain, 4);
11675       ngnuchains = maxchain;
11676
11677     no_gnu_hash:
11678       if (gnuchains == NULL)
11679         {
11680           free (gnubuckets);
11681           gnubuckets = NULL;
11682           ngnubuckets = 0;
11683           if (do_using_dynamic)
11684             return FALSE;
11685         }
11686     }
11687
11688   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11689       && do_syms
11690       && do_using_dynamic
11691       && dynamic_strings != NULL
11692       && dynamic_symbols != NULL)
11693     {
11694       unsigned long hn;
11695
11696       if (dynamic_info[DT_HASH])
11697         {
11698           bfd_vma si;
11699           char *visited;
11700
11701           printf (_("\nSymbol table for image:\n"));
11702           if (is_32bit_elf)
11703             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11704           else
11705             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11706
11707           visited = xcmalloc (nchains, 1);
11708           memset (visited, 0, nchains);
11709           for (hn = 0; hn < nbuckets; hn++)
11710             {
11711               for (si = buckets[hn]; si > 0; si = chains[si])
11712                 {
11713                   print_dynamic_symbol (filedata, si, hn);
11714                   if (si >= nchains || visited[si])
11715                     {
11716                       error (_("histogram chain is corrupt\n"));
11717                       break;
11718                     }
11719                   visited[si] = 1;
11720                 }
11721             }
11722           free (visited);
11723         }
11724
11725       if (dynamic_info_DT_GNU_HASH)
11726         {
11727           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11728           if (is_32bit_elf)
11729             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11730           else
11731             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11732
11733           for (hn = 0; hn < ngnubuckets; ++hn)
11734             if (gnubuckets[hn] != 0)
11735               {
11736                 bfd_vma si = gnubuckets[hn];
11737                 bfd_vma off = si - gnusymidx;
11738
11739                 do
11740                   {
11741                     print_dynamic_symbol (filedata, si, hn);
11742                     si++;
11743                   }
11744                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11745               }
11746         }
11747     }
11748   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11749            && filedata->section_headers != NULL)
11750     {
11751       unsigned int i;
11752
11753       for (i = 0, section = filedata->section_headers;
11754            i < filedata->file_header.e_shnum;
11755            i++, section++)
11756         {
11757           unsigned int si;
11758           char * strtab = NULL;
11759           unsigned long int strtab_size = 0;
11760           Elf_Internal_Sym * symtab;
11761           Elf_Internal_Sym * psym;
11762           unsigned long num_syms;
11763
11764           if ((section->sh_type != SHT_SYMTAB
11765                && section->sh_type != SHT_DYNSYM)
11766               || (!do_syms
11767                   && section->sh_type == SHT_SYMTAB))
11768             continue;
11769
11770           if (section->sh_entsize == 0)
11771             {
11772               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11773                       printable_section_name (filedata, section));
11774               continue;
11775             }
11776
11777           num_syms = section->sh_size / section->sh_entsize;
11778           printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11779                             "\nSymbol table '%s' contains %lu entries:\n",
11780                             num_syms),
11781                   printable_section_name (filedata, section),
11782                   num_syms);
11783
11784           if (is_32bit_elf)
11785             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
11786           else
11787             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
11788
11789           symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
11790           if (symtab == NULL)
11791             continue;
11792
11793           if (section->sh_link == filedata->file_header.e_shstrndx)
11794             {
11795               strtab = filedata->string_table;
11796               strtab_size = filedata->string_table_length;
11797             }
11798           else if (section->sh_link < filedata->file_header.e_shnum)
11799             {
11800               Elf_Internal_Shdr * string_sec;
11801
11802               string_sec = filedata->section_headers + section->sh_link;
11803
11804               strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
11805                                           1, string_sec->sh_size,
11806                                           _("string table"));
11807               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11808             }
11809
11810           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11811             {
11812               const char *version_string;
11813               enum versioned_symbol_info sym_info;
11814               unsigned short vna_other;
11815
11816               printf ("%6d: ", si);
11817               print_vma (psym->st_value, LONG_HEX);
11818               putchar (' ');
11819               print_vma (psym->st_size, DEC_5);
11820               printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11821               printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11822               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11823                 printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11824               else
11825                 {
11826                   unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11827
11828                   printf (" %-7s", get_symbol_visibility (vis));
11829                   /* Check to see if any other bits in the st_other field are set.
11830                      Note - displaying this information disrupts the layout of the
11831                      table being generated, but for the moment this case is very rare.  */
11832                   if (psym->st_other ^ vis)
11833                     printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11834                 }
11835               printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
11836               print_symbol (25, psym->st_name < strtab_size
11837                             ? strtab + psym->st_name : _("<corrupt>"));
11838
11839               version_string
11840                 = get_symbol_version_string (filedata,
11841                                              section->sh_type == SHT_DYNSYM,
11842                                              strtab, strtab_size, si,
11843                                              psym, &sym_info, &vna_other);
11844               if (version_string)
11845                 {
11846                   if (sym_info == symbol_undefined)
11847                     printf ("@%s (%d)", version_string, vna_other);
11848                   else
11849                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11850                             version_string);
11851                 }
11852
11853               putchar ('\n');
11854
11855               if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11856                   && si >= section->sh_info
11857                   /* Irix 5 and 6 MIPS binaries are known to ignore this requirement.  */
11858                   && filedata->file_header.e_machine != EM_MIPS
11859                   /* Solaris binaries have been found to violate this requirement as
11860                      well.  Not sure if this is a bug or an ABI requirement.  */
11861                   && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11862                 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11863                       si, printable_section_name (filedata, section), section->sh_info);
11864             }
11865
11866           free (symtab);
11867           if (strtab != filedata->string_table)
11868             free (strtab);
11869         }
11870     }
11871   else if (do_syms)
11872     printf
11873       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11874
11875   if (do_histogram && buckets != NULL)
11876     {
11877       unsigned long * lengths;
11878       unsigned long * counts;
11879       unsigned long hn;
11880       bfd_vma si;
11881       unsigned long maxlength = 0;
11882       unsigned long nzero_counts = 0;
11883       unsigned long nsyms = 0;
11884       char *visited;
11885
11886       printf (ngettext ("\nHistogram for bucket list length "
11887                         "(total of %lu bucket):\n",
11888                         "\nHistogram for bucket list length "
11889                         "(total of %lu buckets):\n",
11890                         (unsigned long) nbuckets),
11891               (unsigned long) nbuckets);
11892
11893       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11894       if (lengths == NULL)
11895         {
11896           error (_("Out of memory allocating space for histogram buckets\n"));
11897           return FALSE;
11898         }
11899       visited = xcmalloc (nchains, 1);
11900       memset (visited, 0, nchains);
11901
11902       printf (_(" Length  Number     %% of total  Coverage\n"));
11903       for (hn = 0; hn < nbuckets; ++hn)
11904         {
11905           for (si = buckets[hn]; si > 0; si = chains[si])
11906             {
11907               ++nsyms;
11908               if (maxlength < ++lengths[hn])
11909                 ++maxlength;
11910               if (si >= nchains || visited[si])
11911                 {
11912                   error (_("histogram chain is corrupt\n"));
11913                   break;
11914                 }
11915               visited[si] = 1;
11916             }
11917         }
11918       free (visited);
11919
11920       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11921       if (counts == NULL)
11922         {
11923           free (lengths);
11924           error (_("Out of memory allocating space for histogram counts\n"));
11925           return FALSE;
11926         }
11927
11928       for (hn = 0; hn < nbuckets; ++hn)
11929         ++counts[lengths[hn]];
11930
11931       if (nbuckets > 0)
11932         {
11933           unsigned long i;
11934           printf ("      0  %-10lu (%5.1f%%)\n",
11935                   counts[0], (counts[0] * 100.0) / nbuckets);
11936           for (i = 1; i <= maxlength; ++i)
11937             {
11938               nzero_counts += counts[i] * i;
11939               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11940                       i, counts[i], (counts[i] * 100.0) / nbuckets,
11941                       (nzero_counts * 100.0) / nsyms);
11942             }
11943         }
11944
11945       free (counts);
11946       free (lengths);
11947     }
11948
11949   if (buckets != NULL)
11950     {
11951       free (buckets);
11952       free (chains);
11953     }
11954
11955   if (do_histogram && gnubuckets != NULL)
11956     {
11957       unsigned long * lengths;
11958       unsigned long * counts;
11959       unsigned long hn;
11960       unsigned long maxlength = 0;
11961       unsigned long nzero_counts = 0;
11962       unsigned long nsyms = 0;
11963
11964       printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11965                         "(total of %lu bucket):\n",
11966                         "\nHistogram for `.gnu.hash' bucket list length "
11967                         "(total of %lu buckets):\n",
11968                         (unsigned long) ngnubuckets),
11969               (unsigned long) ngnubuckets);
11970
11971       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11972       if (lengths == NULL)
11973         {
11974           error (_("Out of memory allocating space for gnu histogram buckets\n"));
11975           return FALSE;
11976         }
11977
11978       printf (_(" Length  Number     %% of total  Coverage\n"));
11979
11980       for (hn = 0; hn < ngnubuckets; ++hn)
11981         if (gnubuckets[hn] != 0)
11982           {
11983             bfd_vma off, length = 1;
11984
11985             for (off = gnubuckets[hn] - gnusymidx;
11986                  /* PR 17531 file: 010-77222-0.004.  */
11987                  off < ngnuchains && (gnuchains[off] & 1) == 0;
11988                  ++off)
11989               ++length;
11990             lengths[hn] = length;
11991             if (length > maxlength)
11992               maxlength = length;
11993             nsyms += length;
11994           }
11995
11996       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11997       if (counts == NULL)
11998         {
11999           free (lengths);
12000           error (_("Out of memory allocating space for gnu histogram counts\n"));
12001           return FALSE;
12002         }
12003
12004       for (hn = 0; hn < ngnubuckets; ++hn)
12005         ++counts[lengths[hn]];
12006
12007       if (ngnubuckets > 0)
12008         {
12009           unsigned long j;
12010           printf ("      0  %-10lu (%5.1f%%)\n",
12011                   counts[0], (counts[0] * 100.0) / ngnubuckets);
12012           for (j = 1; j <= maxlength; ++j)
12013             {
12014               nzero_counts += counts[j] * j;
12015               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
12016                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
12017                       (nzero_counts * 100.0) / nsyms);
12018             }
12019         }
12020
12021       free (counts);
12022       free (lengths);
12023       free (gnubuckets);
12024       free (gnuchains);
12025     }
12026
12027   return TRUE;
12028 }
12029
12030 static bfd_boolean
12031 process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
12032 {
12033   unsigned int i;
12034
12035   if (dynamic_syminfo == NULL
12036       || !do_dynamic)
12037     /* No syminfo, this is ok.  */
12038     return TRUE;
12039
12040   /* There better should be a dynamic symbol section.  */
12041   if (dynamic_symbols == NULL || dynamic_strings == NULL)
12042     return FALSE;
12043
12044   if (dynamic_addr)
12045     printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12046                       "contains %d entry:\n",
12047                       "\nDynamic info segment at offset 0x%lx "
12048                       "contains %d entries:\n",
12049                       dynamic_syminfo_nent),
12050             dynamic_syminfo_offset, dynamic_syminfo_nent);
12051
12052   printf (_(" Num: Name                           BoundTo     Flags\n"));
12053   for (i = 0; i < dynamic_syminfo_nent; ++i)
12054     {
12055       unsigned short int flags = dynamic_syminfo[i].si_flags;
12056
12057       printf ("%4d: ", i);
12058       if (i >= num_dynamic_syms)
12059         printf (_("<corrupt index>"));
12060       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
12061         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
12062       else
12063         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
12064       putchar (' ');
12065
12066       switch (dynamic_syminfo[i].si_boundto)
12067         {
12068         case SYMINFO_BT_SELF:
12069           fputs ("SELF       ", stdout);
12070           break;
12071         case SYMINFO_BT_PARENT:
12072           fputs ("PARENT     ", stdout);
12073           break;
12074         default:
12075           if (dynamic_syminfo[i].si_boundto > 0
12076               && dynamic_syminfo[i].si_boundto < dynamic_nent
12077               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
12078             {
12079               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
12080               putchar (' ' );
12081             }
12082           else
12083             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
12084           break;
12085         }
12086
12087       if (flags & SYMINFO_FLG_DIRECT)
12088         printf (" DIRECT");
12089       if (flags & SYMINFO_FLG_PASSTHRU)
12090         printf (" PASSTHRU");
12091       if (flags & SYMINFO_FLG_COPY)
12092         printf (" COPY");
12093       if (flags & SYMINFO_FLG_LAZYLOAD)
12094         printf (" LAZYLOAD");
12095
12096       puts ("");
12097     }
12098
12099   return TRUE;
12100 }
12101
12102 #define IN_RANGE(START,END,ADDR,OFF)            \
12103   (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12104
12105 /* Check to see if the given reloc needs to be handled in a target specific
12106    manner.  If so then process the reloc and return TRUE otherwise return
12107    FALSE.
12108
12109    If called with reloc == NULL, then this is a signal that reloc processing
12110    for the current section has finished, and any saved state should be
12111    discarded.  */
12112
12113 static bfd_boolean
12114 target_specific_reloc_handling (Filedata *           filedata,
12115                                 Elf_Internal_Rela *  reloc,
12116                                 unsigned char *      start,
12117                                 unsigned char *      end,
12118                                 Elf_Internal_Sym *   symtab,
12119                                 unsigned long        num_syms)
12120 {
12121   unsigned int reloc_type = 0;
12122   unsigned long sym_index = 0;
12123
12124   if (reloc)
12125     {
12126       reloc_type = get_reloc_type (filedata, reloc->r_info);
12127       sym_index = get_reloc_symindex (reloc->r_info);
12128     }
12129
12130   switch (filedata->file_header.e_machine)
12131     {
12132     case EM_MSP430:
12133     case EM_MSP430_OLD:
12134       {
12135         static Elf_Internal_Sym * saved_sym = NULL;
12136
12137         if (reloc == NULL)
12138           {
12139             saved_sym = NULL;
12140             return TRUE;
12141           }
12142
12143         switch (reloc_type)
12144           {
12145           case 10: /* R_MSP430_SYM_DIFF */
12146             if (uses_msp430x_relocs (filedata))
12147               break;
12148             /* Fall through.  */
12149           case 21: /* R_MSP430X_SYM_DIFF */
12150             /* PR 21139.  */
12151             if (sym_index >= num_syms)
12152               error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12153                      sym_index);
12154             else
12155               saved_sym = symtab + sym_index;
12156             return TRUE;
12157
12158           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12159           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12160             goto handle_sym_diff;
12161
12162           case 5: /* R_MSP430_16_BYTE */
12163           case 9: /* R_MSP430_8 */
12164             if (uses_msp430x_relocs (filedata))
12165               break;
12166             goto handle_sym_diff;
12167
12168           case 2: /* R_MSP430_ABS16 */
12169           case 15: /* R_MSP430X_ABS16 */
12170             if (! uses_msp430x_relocs (filedata))
12171               break;
12172             goto handle_sym_diff;
12173
12174           handle_sym_diff:
12175             if (saved_sym != NULL)
12176               {
12177                 int reloc_size = reloc_type == 1 ? 4 : 2;
12178                 bfd_vma value;
12179
12180                 if (sym_index >= num_syms)
12181                   error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12182                          sym_index);
12183                 else
12184                   {
12185                     value = reloc->r_addend + (symtab[sym_index].st_value
12186                                                - saved_sym->st_value);
12187
12188                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12189                       byte_put (start + reloc->r_offset, value, reloc_size);
12190                     else
12191                       /* PR 21137 */
12192                       error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12193                              (long) reloc->r_offset);
12194                   }
12195
12196                 saved_sym = NULL;
12197                 return TRUE;
12198               }
12199             break;
12200
12201           default:
12202             if (saved_sym != NULL)
12203               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12204             break;
12205           }
12206         break;
12207       }
12208
12209     case EM_MN10300:
12210     case EM_CYGNUS_MN10300:
12211       {
12212         static Elf_Internal_Sym * saved_sym = NULL;
12213
12214         if (reloc == NULL)
12215           {
12216             saved_sym = NULL;
12217             return TRUE;
12218           }
12219
12220         switch (reloc_type)
12221           {
12222           case 34: /* R_MN10300_ALIGN */
12223             return TRUE;
12224           case 33: /* R_MN10300_SYM_DIFF */
12225             if (sym_index >= num_syms)
12226               error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12227                      sym_index);
12228             else
12229               saved_sym = symtab + sym_index;
12230             return TRUE;
12231
12232           case 1: /* R_MN10300_32 */
12233           case 2: /* R_MN10300_16 */
12234             if (saved_sym != NULL)
12235               {
12236                 int reloc_size = reloc_type == 1 ? 4 : 2;
12237                 bfd_vma value;
12238
12239                 if (sym_index >= num_syms)
12240                   error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12241                          sym_index);
12242                 else
12243                   {
12244                     value = reloc->r_addend + (symtab[sym_index].st_value
12245                                                - saved_sym->st_value);
12246
12247                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12248                       byte_put (start + reloc->r_offset, value, reloc_size);
12249                     else
12250                       error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12251                              (long) reloc->r_offset);
12252                   }
12253
12254                 saved_sym = NULL;
12255                 return TRUE;
12256               }
12257             break;
12258           default:
12259             if (saved_sym != NULL)
12260               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12261             break;
12262           }
12263         break;
12264       }
12265
12266     case EM_RL78:
12267       {
12268         static bfd_vma saved_sym1 = 0;
12269         static bfd_vma saved_sym2 = 0;
12270         static bfd_vma value;
12271
12272         if (reloc == NULL)
12273           {
12274             saved_sym1 = saved_sym2 = 0;
12275             return TRUE;
12276           }
12277
12278         switch (reloc_type)
12279           {
12280           case 0x80: /* R_RL78_SYM.  */
12281             saved_sym1 = saved_sym2;
12282             if (sym_index >= num_syms)
12283               error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12284                      sym_index);
12285             else
12286               {
12287                 saved_sym2 = symtab[sym_index].st_value;
12288                 saved_sym2 += reloc->r_addend;
12289               }
12290             return TRUE;
12291
12292           case 0x83: /* R_RL78_OPsub.  */
12293             value = saved_sym1 - saved_sym2;
12294             saved_sym2 = saved_sym1 = 0;
12295             return TRUE;
12296             break;
12297
12298           case 0x41: /* R_RL78_ABS32.  */
12299             if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12300               byte_put (start + reloc->r_offset, value, 4);
12301             else
12302               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12303                      (long) reloc->r_offset);
12304             value = 0;
12305             return TRUE;
12306
12307           case 0x43: /* R_RL78_ABS16.  */
12308             if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12309               byte_put (start + reloc->r_offset, value, 2);
12310             else
12311               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12312                      (long) reloc->r_offset);
12313             value = 0;
12314             return TRUE;
12315
12316           default:
12317             break;
12318           }
12319         break;
12320       }
12321     }
12322
12323   return FALSE;
12324 }
12325
12326 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12327    DWARF debug sections.  This is a target specific test.  Note - we do not
12328    go through the whole including-target-headers-multiple-times route, (as
12329    we have already done with <elf/h8.h>) because this would become very
12330    messy and even then this function would have to contain target specific
12331    information (the names of the relocs instead of their numeric values).
12332    FIXME: This is not the correct way to solve this problem.  The proper way
12333    is to have target specific reloc sizing and typing functions created by
12334    the reloc-macros.h header, in the same way that it already creates the
12335    reloc naming functions.  */
12336
12337 static bfd_boolean
12338 is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12339 {
12340   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12341   switch (filedata->file_header.e_machine)
12342     {
12343     case EM_386:
12344     case EM_IAMCU:
12345       return reloc_type == 1; /* R_386_32.  */
12346     case EM_68K:
12347       return reloc_type == 1; /* R_68K_32.  */
12348     case EM_860:
12349       return reloc_type == 1; /* R_860_32.  */
12350     case EM_960:
12351       return reloc_type == 2; /* R_960_32.  */
12352     case EM_AARCH64:
12353       return (reloc_type == 258
12354               || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12355     case EM_ADAPTEVA_EPIPHANY:
12356       return reloc_type == 3;
12357     case EM_ALPHA:
12358       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
12359     case EM_ARC:
12360       return reloc_type == 1; /* R_ARC_32.  */
12361     case EM_ARC_COMPACT:
12362     case EM_ARC_COMPACT2:
12363       return reloc_type == 4; /* R_ARC_32.  */
12364     case EM_ARM:
12365       return reloc_type == 2; /* R_ARM_ABS32 */
12366     case EM_AVR_OLD:
12367     case EM_AVR:
12368       return reloc_type == 1;
12369     case EM_BLACKFIN:
12370       return reloc_type == 0x12; /* R_byte4_data.  */
12371     case EM_CRIS:
12372       return reloc_type == 3; /* R_CRIS_32.  */
12373     case EM_CR16:
12374       return reloc_type == 3; /* R_CR16_NUM32.  */
12375     case EM_CRX:
12376       return reloc_type == 15; /* R_CRX_NUM32.  */
12377     case EM_CSKY:
12378       return reloc_type == 1; /* R_CKCORE_ADDR32.  */
12379     case EM_CYGNUS_FRV:
12380       return reloc_type == 1;
12381     case EM_CYGNUS_D10V:
12382     case EM_D10V:
12383       return reloc_type == 6; /* R_D10V_32.  */
12384     case EM_CYGNUS_D30V:
12385     case EM_D30V:
12386       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
12387     case EM_DLX:
12388       return reloc_type == 3; /* R_DLX_RELOC_32.  */
12389     case EM_CYGNUS_FR30:
12390     case EM_FR30:
12391       return reloc_type == 3; /* R_FR30_32.  */
12392     case EM_FT32:
12393       return reloc_type == 1; /* R_FT32_32.  */
12394     case EM_H8S:
12395     case EM_H8_300:
12396     case EM_H8_300H:
12397       return reloc_type == 1; /* R_H8_DIR32.  */
12398     case EM_IA_64:
12399       return (reloc_type == 0x64    /* R_IA64_SECREL32MSB.  */
12400               || reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
12401               || reloc_type == 0x24 /* R_IA64_DIR32MSB.  */
12402               || reloc_type == 0x25 /* R_IA64_DIR32LSB.  */);
12403     case EM_IP2K_OLD:
12404     case EM_IP2K:
12405       return reloc_type == 2; /* R_IP2K_32.  */
12406     case EM_IQ2000:
12407       return reloc_type == 2; /* R_IQ2000_32.  */
12408     case EM_LATTICEMICO32:
12409       return reloc_type == 3; /* R_LM32_32.  */
12410     case EM_M32C_OLD:
12411     case EM_M32C:
12412       return reloc_type == 3; /* R_M32C_32.  */
12413     case EM_M32R:
12414       return reloc_type == 34; /* R_M32R_32_RELA.  */
12415     case EM_68HC11:
12416     case EM_68HC12:
12417       return reloc_type == 6; /* R_M68HC11_32.  */
12418     case EM_S12Z:
12419       return reloc_type == 7 || /* R_S12Z_EXT32 */
12420         reloc_type == 6;        /* R_S12Z_CW32.  */
12421     case EM_MCORE:
12422       return reloc_type == 1; /* R_MCORE_ADDR32.  */
12423     case EM_CYGNUS_MEP:
12424       return reloc_type == 4; /* R_MEP_32.  */
12425     case EM_METAG:
12426       return reloc_type == 2; /* R_METAG_ADDR32.  */
12427     case EM_MICROBLAZE:
12428       return reloc_type == 1; /* R_MICROBLAZE_32.  */
12429     case EM_MIPS:
12430       return reloc_type == 2; /* R_MIPS_32.  */
12431     case EM_MMIX:
12432       return reloc_type == 4; /* R_MMIX_32.  */
12433     case EM_CYGNUS_MN10200:
12434     case EM_MN10200:
12435       return reloc_type == 1; /* R_MN10200_32.  */
12436     case EM_CYGNUS_MN10300:
12437     case EM_MN10300:
12438       return reloc_type == 1; /* R_MN10300_32.  */
12439     case EM_MOXIE:
12440       return reloc_type == 1; /* R_MOXIE_32.  */
12441     case EM_MSP430_OLD:
12442     case EM_MSP430:
12443       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
12444     case EM_MT:
12445       return reloc_type == 2; /* R_MT_32.  */
12446     case EM_NDS32:
12447       return reloc_type == 20; /* R_NDS32_RELA.  */
12448     case EM_ALTERA_NIOS2:
12449       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
12450     case EM_NIOS32:
12451       return reloc_type == 1; /* R_NIOS_32.  */
12452     case EM_OR1K:
12453       return reloc_type == 1; /* R_OR1K_32.  */
12454     case EM_PARISC:
12455       return (reloc_type == 1 /* R_PARISC_DIR32.  */
12456               || reloc_type == 2 /* R_PARISC_DIR21L.  */
12457               || reloc_type == 41); /* R_PARISC_SECREL32.  */
12458     case EM_PJ:
12459     case EM_PJ_OLD:
12460       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
12461     case EM_PPC64:
12462       return reloc_type == 1; /* R_PPC64_ADDR32.  */
12463     case EM_PPC:
12464       return reloc_type == 1; /* R_PPC_ADDR32.  */
12465     case EM_TI_PRU:
12466       return reloc_type == 11; /* R_PRU_BFD_RELOC_32.  */
12467     case EM_RISCV:
12468       return reloc_type == 1; /* R_RISCV_32.  */
12469     case EM_RL78:
12470       return reloc_type == 1; /* R_RL78_DIR32.  */
12471     case EM_RX:
12472       return reloc_type == 1; /* R_RX_DIR32.  */
12473     case EM_S370:
12474       return reloc_type == 1; /* R_I370_ADDR31.  */
12475     case EM_S390_OLD:
12476     case EM_S390:
12477       return reloc_type == 4; /* R_S390_32.  */
12478     case EM_SCORE:
12479       return reloc_type == 8; /* R_SCORE_ABS32.  */
12480     case EM_SH:
12481       return reloc_type == 1; /* R_SH_DIR32.  */
12482     case EM_SPARC32PLUS:
12483     case EM_SPARCV9:
12484     case EM_SPARC:
12485       return reloc_type == 3 /* R_SPARC_32.  */
12486         || reloc_type == 23; /* R_SPARC_UA32.  */
12487     case EM_SPU:
12488       return reloc_type == 6; /* R_SPU_ADDR32 */
12489     case EM_TI_C6000:
12490       return reloc_type == 1; /* R_C6000_ABS32.  */
12491     case EM_TILEGX:
12492       return reloc_type == 2; /* R_TILEGX_32.  */
12493     case EM_TILEPRO:
12494       return reloc_type == 1; /* R_TILEPRO_32.  */
12495     case EM_CYGNUS_V850:
12496     case EM_V850:
12497       return reloc_type == 6; /* R_V850_ABS32.  */
12498     case EM_V800:
12499       return reloc_type == 0x33; /* R_V810_WORD.  */
12500     case EM_VAX:
12501       return reloc_type == 1; /* R_VAX_32.  */
12502     case EM_VISIUM:
12503       return reloc_type == 3;  /* R_VISIUM_32. */
12504     case EM_WEBASSEMBLY:
12505       return reloc_type == 1;  /* R_WASM32_32.  */
12506     case EM_X86_64:
12507     case EM_L1OM:
12508     case EM_K1OM:
12509       return reloc_type == 10; /* R_X86_64_32.  */
12510     case EM_XC16X:
12511     case EM_C166:
12512       return reloc_type == 3; /* R_XC16C_ABS_32.  */
12513     case EM_XGATE:
12514       return reloc_type == 4; /* R_XGATE_32.  */
12515     case EM_XSTORMY16:
12516       return reloc_type == 1; /* R_XSTROMY16_32.  */
12517     case EM_XTENSA_OLD:
12518     case EM_XTENSA:
12519       return reloc_type == 1; /* R_XTENSA_32.  */
12520     default:
12521       {
12522         static unsigned int prev_warn = 0;
12523
12524         /* Avoid repeating the same warning multiple times.  */
12525         if (prev_warn != filedata->file_header.e_machine)
12526           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12527                  filedata->file_header.e_machine);
12528         prev_warn = filedata->file_header.e_machine;
12529         return FALSE;
12530       }
12531     }
12532 }
12533
12534 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12535    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
12536
12537 static bfd_boolean
12538 is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12539 {
12540   switch (filedata->file_header.e_machine)
12541   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12542     {
12543     case EM_386:
12544     case EM_IAMCU:
12545       return reloc_type == 2;  /* R_386_PC32.  */
12546     case EM_68K:
12547       return reloc_type == 4;  /* R_68K_PC32.  */
12548     case EM_AARCH64:
12549       return reloc_type == 261; /* R_AARCH64_PREL32 */
12550     case EM_ADAPTEVA_EPIPHANY:
12551       return reloc_type == 6;
12552     case EM_ALPHA:
12553       return reloc_type == 10; /* R_ALPHA_SREL32.  */
12554     case EM_ARC_COMPACT:
12555     case EM_ARC_COMPACT2:
12556       return reloc_type == 49; /* R_ARC_32_PCREL.  */
12557     case EM_ARM:
12558       return reloc_type == 3;  /* R_ARM_REL32 */
12559     case EM_AVR_OLD:
12560     case EM_AVR:
12561       return reloc_type == 36; /* R_AVR_32_PCREL.  */
12562     case EM_MICROBLAZE:
12563       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
12564     case EM_OR1K:
12565       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
12566     case EM_PARISC:
12567       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
12568     case EM_PPC:
12569       return reloc_type == 26; /* R_PPC_REL32.  */
12570     case EM_PPC64:
12571       return reloc_type == 26; /* R_PPC64_REL32.  */
12572     case EM_RISCV:
12573       return reloc_type == 57;  /* R_RISCV_32_PCREL.  */
12574     case EM_S390_OLD:
12575     case EM_S390:
12576       return reloc_type == 5;  /* R_390_PC32.  */
12577     case EM_SH:
12578       return reloc_type == 2;  /* R_SH_REL32.  */
12579     case EM_SPARC32PLUS:
12580     case EM_SPARCV9:
12581     case EM_SPARC:
12582       return reloc_type == 6;  /* R_SPARC_DISP32.  */
12583     case EM_SPU:
12584       return reloc_type == 13; /* R_SPU_REL32.  */
12585     case EM_TILEGX:
12586       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
12587     case EM_TILEPRO:
12588       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
12589     case EM_VISIUM:
12590       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
12591     case EM_X86_64:
12592     case EM_L1OM:
12593     case EM_K1OM:
12594       return reloc_type == 2;  /* R_X86_64_PC32.  */
12595     case EM_XTENSA_OLD:
12596     case EM_XTENSA:
12597       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
12598     default:
12599       /* Do not abort or issue an error message here.  Not all targets use
12600          pc-relative 32-bit relocs in their DWARF debug information and we
12601          have already tested for target coverage in is_32bit_abs_reloc.  A
12602          more helpful warning message will be generated by apply_relocations
12603          anyway, so just return.  */
12604       return FALSE;
12605     }
12606 }
12607
12608 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12609    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
12610
12611 static bfd_boolean
12612 is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12613 {
12614   switch (filedata->file_header.e_machine)
12615     {
12616     case EM_AARCH64:
12617       return reloc_type == 257; /* R_AARCH64_ABS64.  */
12618     case EM_ALPHA:
12619       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
12620     case EM_IA_64:
12621       return (reloc_type == 0x26    /* R_IA64_DIR64MSB.  */
12622               || reloc_type == 0x27 /* R_IA64_DIR64LSB.  */);
12623     case EM_PARISC:
12624       return reloc_type == 80; /* R_PARISC_DIR64.  */
12625     case EM_PPC64:
12626       return reloc_type == 38; /* R_PPC64_ADDR64.  */
12627     case EM_RISCV:
12628       return reloc_type == 2; /* R_RISCV_64.  */
12629     case EM_SPARC32PLUS:
12630     case EM_SPARCV9:
12631     case EM_SPARC:
12632       return reloc_type == 32 /* R_SPARC_64.  */
12633         || reloc_type == 54; /* R_SPARC_UA64.  */
12634     case EM_X86_64:
12635     case EM_L1OM:
12636     case EM_K1OM:
12637       return reloc_type == 1; /* R_X86_64_64.  */
12638     case EM_S390_OLD:
12639     case EM_S390:
12640       return reloc_type == 22;  /* R_S390_64.  */
12641     case EM_TILEGX:
12642       return reloc_type == 1; /* R_TILEGX_64.  */
12643     case EM_MIPS:
12644       return reloc_type == 18;  /* R_MIPS_64.  */
12645     default:
12646       return FALSE;
12647     }
12648 }
12649
12650 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12651    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
12652
12653 static bfd_boolean
12654 is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12655 {
12656   switch (filedata->file_header.e_machine)
12657     {
12658     case EM_AARCH64:
12659       return reloc_type == 260; /* R_AARCH64_PREL64.  */
12660     case EM_ALPHA:
12661       return reloc_type == 11; /* R_ALPHA_SREL64.  */
12662     case EM_IA_64:
12663       return (reloc_type == 0x4e    /* R_IA64_PCREL64MSB.  */
12664               || reloc_type == 0x4f /* R_IA64_PCREL64LSB.  */);
12665     case EM_PARISC:
12666       return reloc_type == 72; /* R_PARISC_PCREL64.  */
12667     case EM_PPC64:
12668       return reloc_type == 44; /* R_PPC64_REL64.  */
12669     case EM_SPARC32PLUS:
12670     case EM_SPARCV9:
12671     case EM_SPARC:
12672       return reloc_type == 46; /* R_SPARC_DISP64.  */
12673     case EM_X86_64:
12674     case EM_L1OM:
12675     case EM_K1OM:
12676       return reloc_type == 24; /* R_X86_64_PC64.  */
12677     case EM_S390_OLD:
12678     case EM_S390:
12679       return reloc_type == 23;  /* R_S390_PC64.  */
12680     case EM_TILEGX:
12681       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
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 24-bit absolute RELA relocation used in DWARF debug sections.  */
12689
12690 static bfd_boolean
12691 is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12692 {
12693   switch (filedata->file_header.e_machine)
12694     {
12695     case EM_CYGNUS_MN10200:
12696     case EM_MN10200:
12697       return reloc_type == 4; /* R_MN10200_24.  */
12698     case EM_FT32:
12699       return reloc_type == 5; /* R_FT32_20.  */
12700     default:
12701       return FALSE;
12702     }
12703 }
12704
12705 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12706    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
12707
12708 static bfd_boolean
12709 is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12710 {
12711   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12712   switch (filedata->file_header.e_machine)
12713     {
12714     case EM_ARC:
12715     case EM_ARC_COMPACT:
12716     case EM_ARC_COMPACT2:
12717       return reloc_type == 2; /* R_ARC_16.  */
12718     case EM_ADAPTEVA_EPIPHANY:
12719       return reloc_type == 5;
12720     case EM_AVR_OLD:
12721     case EM_AVR:
12722       return reloc_type == 4; /* R_AVR_16.  */
12723     case EM_CYGNUS_D10V:
12724     case EM_D10V:
12725       return reloc_type == 3; /* R_D10V_16.  */
12726     case EM_FT32:
12727       return reloc_type == 2; /* R_FT32_16.  */
12728     case EM_H8S:
12729     case EM_H8_300:
12730     case EM_H8_300H:
12731       return reloc_type == R_H8_DIR16;
12732     case EM_IP2K_OLD:
12733     case EM_IP2K:
12734       return reloc_type == 1; /* R_IP2K_16.  */
12735     case EM_M32C_OLD:
12736     case EM_M32C:
12737       return reloc_type == 1; /* R_M32C_16 */
12738     case EM_CYGNUS_MN10200:
12739     case EM_MN10200:
12740       return reloc_type == 2; /* R_MN10200_16.  */
12741     case EM_CYGNUS_MN10300:
12742     case EM_MN10300:
12743       return reloc_type == 2; /* R_MN10300_16.  */
12744     case EM_MSP430:
12745       if (uses_msp430x_relocs (filedata))
12746         return reloc_type == 2; /* R_MSP430_ABS16.  */
12747       /* Fall through.  */
12748     case EM_MSP430_OLD:
12749       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
12750     case EM_NDS32:
12751       return reloc_type == 19; /* R_NDS32_RELA.  */
12752     case EM_ALTERA_NIOS2:
12753       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
12754     case EM_NIOS32:
12755       return reloc_type == 9; /* R_NIOS_16.  */
12756     case EM_OR1K:
12757       return reloc_type == 2; /* R_OR1K_16.  */
12758     case EM_RISCV:
12759       return reloc_type == 55; /* R_RISCV_SET16.  */
12760     case EM_TI_PRU:
12761       return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
12762     case EM_TI_C6000:
12763       return reloc_type == 2; /* R_C6000_ABS16.  */
12764     case EM_VISIUM:
12765       return reloc_type == 2; /* R_VISIUM_16. */
12766     case EM_XC16X:
12767     case EM_C166:
12768       return reloc_type == 2; /* R_XC16C_ABS_16.  */
12769     case EM_XGATE:
12770       return reloc_type == 3; /* R_XGATE_16.  */
12771     default:
12772       return FALSE;
12773     }
12774 }
12775
12776 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12777    a 8-bit absolute RELA relocation used in DWARF debug sections.  */
12778
12779 static bfd_boolean
12780 is_8bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12781 {
12782   switch (filedata->file_header.e_machine)
12783     {
12784     case EM_RISCV:
12785       return reloc_type == 54; /* R_RISCV_SET8.  */
12786     default:
12787       return FALSE;
12788     }
12789 }
12790
12791 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12792    a 6-bit absolute RELA relocation used in DWARF debug sections.  */
12793
12794 static bfd_boolean
12795 is_6bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12796 {
12797   switch (filedata->file_header.e_machine)
12798     {
12799     case EM_RISCV:
12800       return reloc_type == 53; /* R_RISCV_SET6.  */
12801     default:
12802       return FALSE;
12803     }
12804 }
12805
12806 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12807    a 32-bit inplace add RELA relocation used in DWARF debug sections.  */
12808
12809 static bfd_boolean
12810 is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12811 {
12812   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12813   switch (filedata->file_header.e_machine)
12814     {
12815     case EM_RISCV:
12816       return reloc_type == 35; /* R_RISCV_ADD32.  */
12817     default:
12818       return FALSE;
12819     }
12820 }
12821
12822 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12823    a 32-bit inplace sub RELA relocation used in DWARF debug sections.  */
12824
12825 static bfd_boolean
12826 is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12827 {
12828   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12829   switch (filedata->file_header.e_machine)
12830     {
12831     case EM_RISCV:
12832       return reloc_type == 39; /* R_RISCV_SUB32.  */
12833     default:
12834       return FALSE;
12835     }
12836 }
12837
12838 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12839    a 64-bit inplace add RELA relocation used in DWARF debug sections.  */
12840
12841 static bfd_boolean
12842 is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12843 {
12844   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12845   switch (filedata->file_header.e_machine)
12846     {
12847     case EM_RISCV:
12848       return reloc_type == 36; /* R_RISCV_ADD64.  */
12849     default:
12850       return FALSE;
12851     }
12852 }
12853
12854 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12855    a 64-bit inplace sub RELA relocation used in DWARF debug sections.  */
12856
12857 static bfd_boolean
12858 is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12859 {
12860   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12861   switch (filedata->file_header.e_machine)
12862     {
12863     case EM_RISCV:
12864       return reloc_type == 40; /* R_RISCV_SUB64.  */
12865     default:
12866       return FALSE;
12867     }
12868 }
12869
12870 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12871    a 16-bit inplace add RELA relocation used in DWARF debug sections.  */
12872
12873 static bfd_boolean
12874 is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12875 {
12876   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12877   switch (filedata->file_header.e_machine)
12878     {
12879     case EM_RISCV:
12880       return reloc_type == 34; /* R_RISCV_ADD16.  */
12881     default:
12882       return FALSE;
12883     }
12884 }
12885
12886 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12887    a 16-bit inplace sub RELA relocation used in DWARF debug sections.  */
12888
12889 static bfd_boolean
12890 is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12891 {
12892   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12893   switch (filedata->file_header.e_machine)
12894     {
12895     case EM_RISCV:
12896       return reloc_type == 38; /* R_RISCV_SUB16.  */
12897     default:
12898       return FALSE;
12899     }
12900 }
12901
12902 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12903    a 8-bit inplace add RELA relocation used in DWARF debug sections.  */
12904
12905 static bfd_boolean
12906 is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12907 {
12908   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12909   switch (filedata->file_header.e_machine)
12910     {
12911     case EM_RISCV:
12912       return reloc_type == 33; /* R_RISCV_ADD8.  */
12913     default:
12914       return FALSE;
12915     }
12916 }
12917
12918 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12919    a 8-bit inplace sub RELA relocation used in DWARF debug sections.  */
12920
12921 static bfd_boolean
12922 is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12923 {
12924   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12925   switch (filedata->file_header.e_machine)
12926     {
12927     case EM_RISCV:
12928       return reloc_type == 37; /* R_RISCV_SUB8.  */
12929     default:
12930       return FALSE;
12931     }
12932 }
12933
12934 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12935    a 6-bit inplace sub RELA relocation used in DWARF debug sections.  */
12936
12937 static bfd_boolean
12938 is_6bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12939 {
12940   switch (filedata->file_header.e_machine)
12941     {
12942     case EM_RISCV:
12943       return reloc_type == 52; /* R_RISCV_SUB6.  */
12944     default:
12945       return FALSE;
12946     }
12947 }
12948
12949 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12950    relocation entries (possibly formerly used for SHT_GROUP sections).  */
12951
12952 static bfd_boolean
12953 is_none_reloc (Filedata * filedata, unsigned int reloc_type)
12954 {
12955   switch (filedata->file_header.e_machine)
12956     {
12957     case EM_386:     /* R_386_NONE.  */
12958     case EM_68K:     /* R_68K_NONE.  */
12959     case EM_ADAPTEVA_EPIPHANY:
12960     case EM_ALPHA:   /* R_ALPHA_NONE.  */
12961     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
12962     case EM_ARC:     /* R_ARC_NONE.  */
12963     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
12964     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
12965     case EM_ARM:     /* R_ARM_NONE.  */
12966     case EM_C166:    /* R_XC16X_NONE.  */
12967     case EM_CRIS:    /* R_CRIS_NONE.  */
12968     case EM_FT32:    /* R_FT32_NONE.  */
12969     case EM_IA_64:   /* R_IA64_NONE.  */
12970     case EM_K1OM:    /* R_X86_64_NONE.  */
12971     case EM_L1OM:    /* R_X86_64_NONE.  */
12972     case EM_M32R:    /* R_M32R_NONE.  */
12973     case EM_MIPS:    /* R_MIPS_NONE.  */
12974     case EM_MN10300: /* R_MN10300_NONE.  */
12975     case EM_MOXIE:   /* R_MOXIE_NONE.  */
12976     case EM_NIOS32:  /* R_NIOS_NONE.  */
12977     case EM_OR1K:    /* R_OR1K_NONE. */
12978     case EM_PARISC:  /* R_PARISC_NONE.  */
12979     case EM_PPC64:   /* R_PPC64_NONE.  */
12980     case EM_PPC:     /* R_PPC_NONE.  */
12981     case EM_RISCV:   /* R_RISCV_NONE.  */
12982     case EM_S390:    /* R_390_NONE.  */
12983     case EM_S390_OLD:
12984     case EM_SH:      /* R_SH_NONE.  */
12985     case EM_SPARC32PLUS:
12986     case EM_SPARC:   /* R_SPARC_NONE.  */
12987     case EM_SPARCV9:
12988     case EM_TILEGX:  /* R_TILEGX_NONE.  */
12989     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
12990     case EM_TI_C6000:/* R_C6000_NONE.  */
12991     case EM_X86_64:  /* R_X86_64_NONE.  */
12992     case EM_XC16X:
12993     case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
12994       return reloc_type == 0;
12995
12996     case EM_AARCH64:
12997       return reloc_type == 0 || reloc_type == 256;
12998     case EM_AVR_OLD:
12999     case EM_AVR:
13000       return (reloc_type == 0 /* R_AVR_NONE.  */
13001               || reloc_type == 30 /* R_AVR_DIFF8.  */
13002               || reloc_type == 31 /* R_AVR_DIFF16.  */
13003               || reloc_type == 32 /* R_AVR_DIFF32.  */);
13004     case EM_METAG:
13005       return reloc_type == 3; /* R_METAG_NONE.  */
13006     case EM_NDS32:
13007       return (reloc_type == 0       /* R_XTENSA_NONE.  */
13008               || reloc_type == 204  /* R_NDS32_DIFF8.  */
13009               || reloc_type == 205  /* R_NDS32_DIFF16.  */
13010               || reloc_type == 206  /* R_NDS32_DIFF32.  */
13011               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
13012     case EM_TI_PRU:
13013       return (reloc_type == 0       /* R_PRU_NONE.  */
13014               || reloc_type == 65   /* R_PRU_DIFF8.  */
13015               || reloc_type == 66   /* R_PRU_DIFF16.  */
13016               || reloc_type == 67   /* R_PRU_DIFF32.  */);
13017     case EM_XTENSA_OLD:
13018     case EM_XTENSA:
13019       return (reloc_type == 0      /* R_XTENSA_NONE.  */
13020               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
13021               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
13022               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
13023     }
13024   return FALSE;
13025 }
13026
13027 /* Returns TRUE if there is a relocation against
13028    section NAME at OFFSET bytes.  */
13029
13030 bfd_boolean
13031 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
13032 {
13033   Elf_Internal_Rela * relocs;
13034   Elf_Internal_Rela * rp;
13035
13036   if (dsec == NULL || dsec->reloc_info == NULL)
13037     return FALSE;
13038
13039   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
13040
13041   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
13042     if (rp->r_offset == offset)
13043       return TRUE;
13044
13045    return FALSE;
13046 }
13047
13048 /* Apply relocations to a section.
13049    Returns TRUE upon success, FALSE otherwise.
13050    If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13051    It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
13052    will be set to the number of relocs loaded.
13053
13054    Note: So far support has been added only for those relocations
13055    which can be found in debug sections. FIXME: Add support for
13056    more relocations ?  */
13057
13058 static bfd_boolean
13059 apply_relocations (Filedata *                 filedata,
13060                    const Elf_Internal_Shdr *  section,
13061                    unsigned char *            start,
13062                    bfd_size_type              size,
13063                    void **                    relocs_return,
13064                    unsigned long *            num_relocs_return)
13065 {
13066   Elf_Internal_Shdr * relsec;
13067   unsigned char * end = start + size;
13068
13069   if (relocs_return != NULL)
13070     {
13071       * (Elf_Internal_Rela **) relocs_return = NULL;
13072       * num_relocs_return = 0;
13073     }
13074
13075   if (filedata->file_header.e_type != ET_REL)
13076     /* No relocs to apply.  */
13077     return TRUE;
13078
13079   /* Find the reloc section associated with the section.  */
13080   for (relsec = filedata->section_headers;
13081        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13082        ++relsec)
13083     {
13084       bfd_boolean is_rela;
13085       unsigned long num_relocs;
13086       Elf_Internal_Rela * relocs;
13087       Elf_Internal_Rela * rp;
13088       Elf_Internal_Shdr * symsec;
13089       Elf_Internal_Sym * symtab;
13090       unsigned long num_syms;
13091       Elf_Internal_Sym * sym;
13092
13093       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13094           || relsec->sh_info >= filedata->file_header.e_shnum
13095           || filedata->section_headers + relsec->sh_info != section
13096           || relsec->sh_size == 0
13097           || relsec->sh_link >= filedata->file_header.e_shnum)
13098         continue;
13099
13100       is_rela = relsec->sh_type == SHT_RELA;
13101
13102       if (is_rela)
13103         {
13104           if (!slurp_rela_relocs (filedata, relsec->sh_offset,
13105                                   relsec->sh_size, & relocs, & num_relocs))
13106             return FALSE;
13107         }
13108       else
13109         {
13110           if (!slurp_rel_relocs (filedata, relsec->sh_offset,
13111                                  relsec->sh_size, & relocs, & num_relocs))
13112             return FALSE;
13113         }
13114
13115       /* SH uses RELA but uses in place value instead of the addend field.  */
13116       if (filedata->file_header.e_machine == EM_SH)
13117         is_rela = FALSE;
13118
13119       symsec = filedata->section_headers + relsec->sh_link;
13120       if (symsec->sh_type != SHT_SYMTAB
13121           && symsec->sh_type != SHT_DYNSYM)
13122         return FALSE;
13123       symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
13124
13125       for (rp = relocs; rp < relocs + num_relocs; ++rp)
13126         {
13127           bfd_vma         addend;
13128           unsigned int    reloc_type;
13129           unsigned int    reloc_size;
13130           bfd_boolean     reloc_inplace = FALSE;
13131           bfd_boolean     reloc_subtract = FALSE;
13132           unsigned char * rloc;
13133           unsigned long   sym_index;
13134
13135           reloc_type = get_reloc_type (filedata, rp->r_info);
13136
13137           if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
13138             continue;
13139           else if (is_none_reloc (filedata, reloc_type))
13140             continue;
13141           else if (is_32bit_abs_reloc (filedata, reloc_type)
13142                    || is_32bit_pcrel_reloc (filedata, reloc_type))
13143             reloc_size = 4;
13144           else if (is_64bit_abs_reloc (filedata, reloc_type)
13145                    || is_64bit_pcrel_reloc (filedata, reloc_type))
13146             reloc_size = 8;
13147           else if (is_24bit_abs_reloc (filedata, reloc_type))
13148             reloc_size = 3;
13149           else if (is_16bit_abs_reloc (filedata, reloc_type))
13150             reloc_size = 2;
13151           else if (is_8bit_abs_reloc (filedata, reloc_type)
13152                    || is_6bit_abs_reloc (filedata, reloc_type))
13153             reloc_size = 1;
13154           else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
13155                                                                  reloc_type))
13156                    || is_32bit_inplace_add_reloc (filedata, reloc_type))
13157             {
13158               reloc_size = 4;
13159               reloc_inplace = TRUE;
13160             }
13161           else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
13162                                                                  reloc_type))
13163                    || is_64bit_inplace_add_reloc (filedata, reloc_type))
13164             {
13165               reloc_size = 8;
13166               reloc_inplace = TRUE;
13167             }
13168           else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
13169                                                                  reloc_type))
13170                    || is_16bit_inplace_add_reloc (filedata, reloc_type))
13171             {
13172               reloc_size = 2;
13173               reloc_inplace = TRUE;
13174             }
13175           else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
13176                                                                 reloc_type))
13177                    || is_8bit_inplace_add_reloc (filedata, reloc_type))
13178             {
13179               reloc_size = 1;
13180               reloc_inplace = TRUE;
13181             }
13182           else if ((reloc_subtract = is_6bit_inplace_sub_reloc (filedata,
13183                                                                 reloc_type)))
13184             {
13185               reloc_size = 1;
13186               reloc_inplace = TRUE;
13187             }
13188           else
13189             {
13190               static unsigned int prev_reloc = 0;
13191
13192               if (reloc_type != prev_reloc)
13193                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13194                       reloc_type, printable_section_name (filedata, section));
13195               prev_reloc = reloc_type;
13196               continue;
13197             }
13198
13199           rloc = start + rp->r_offset;
13200           if ((rloc + reloc_size) > end || (rloc < start))
13201             {
13202               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13203                     (unsigned long) rp->r_offset,
13204                     printable_section_name (filedata, section));
13205               continue;
13206             }
13207
13208           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
13209           if (sym_index >= num_syms)
13210             {
13211               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13212                     sym_index, printable_section_name (filedata, section));
13213               continue;
13214             }
13215           sym = symtab + sym_index;
13216
13217           /* If the reloc has a symbol associated with it,
13218              make sure that it is of an appropriate type.
13219
13220              Relocations against symbols without type can happen.
13221              Gcc -feliminate-dwarf2-dups may generate symbols
13222              without type for debug info.
13223
13224              Icc generates relocations against function symbols
13225              instead of local labels.
13226
13227              Relocations against object symbols can happen, eg when
13228              referencing a global array.  For an example of this see
13229              the _clz.o binary in libgcc.a.  */
13230           if (sym != symtab
13231               && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13232               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13233             {
13234               warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13235                     get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13236                     printable_section_name (filedata, relsec),
13237                     (long int)(rp - relocs));
13238               continue;
13239             }
13240
13241           addend = 0;
13242           if (is_rela)
13243             addend += rp->r_addend;
13244           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13245              partial_inplace.  */
13246           if (!is_rela
13247               || (filedata->file_header.e_machine == EM_XTENSA
13248                   && reloc_type == 1)
13249               || ((filedata->file_header.e_machine == EM_PJ
13250                    || filedata->file_header.e_machine == EM_PJ_OLD)
13251                   && reloc_type == 1)
13252               || ((filedata->file_header.e_machine == EM_D30V
13253                    || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13254                   && reloc_type == 12)
13255               || reloc_inplace)
13256             {
13257               if (is_6bit_inplace_sub_reloc (filedata, reloc_type))
13258                 addend += byte_get (rloc, reloc_size) & 0x3f;
13259               else
13260                 addend += byte_get (rloc, reloc_size);
13261             }
13262
13263           if (is_32bit_pcrel_reloc (filedata, reloc_type)
13264               || is_64bit_pcrel_reloc (filedata, reloc_type))
13265             {
13266               /* On HPPA, all pc-relative relocations are biased by 8.  */
13267               if (filedata->file_header.e_machine == EM_PARISC)
13268                 addend -= 8;
13269               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13270                         reloc_size);
13271             }
13272           else if (is_6bit_abs_reloc (filedata, reloc_type)
13273                    || is_6bit_inplace_sub_reloc (filedata, reloc_type))
13274             {
13275               if (reloc_subtract)
13276                 addend -= sym->st_value;
13277               else
13278                 addend += sym->st_value;
13279               addend = (addend & 0x3f) | (byte_get (rloc, reloc_size) & 0xc0);
13280               byte_put (rloc, addend, reloc_size);
13281             }
13282           else if (reloc_subtract)
13283             byte_put (rloc, addend - sym->st_value, reloc_size);
13284           else
13285             byte_put (rloc, addend + sym->st_value, reloc_size);
13286         }
13287
13288       free (symtab);
13289       /* Let the target specific reloc processing code know that
13290          we have finished with these relocs.  */
13291       target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13292
13293       if (relocs_return)
13294         {
13295           * (Elf_Internal_Rela **) relocs_return = relocs;
13296           * num_relocs_return = num_relocs;
13297         }
13298       else
13299         free (relocs);
13300
13301       break;
13302     }
13303
13304   return TRUE;
13305 }
13306
13307 #ifdef SUPPORT_DISASSEMBLY
13308 static bfd_boolean
13309 disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13310 {
13311   printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13312
13313   /* FIXME: XXX -- to be done --- XXX */
13314
13315   return TRUE;
13316 }
13317 #endif
13318
13319 /* Reads in the contents of SECTION from FILE, returning a pointer
13320    to a malloc'ed buffer or NULL if something went wrong.  */
13321
13322 static char *
13323 get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13324 {
13325   bfd_size_type num_bytes = section->sh_size;
13326
13327   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13328     {
13329       printf (_("Section '%s' has no data to dump.\n"),
13330               printable_section_name (filedata, section));
13331       return NULL;
13332     }
13333
13334   return  (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13335                              _("section contents"));
13336 }
13337
13338 /* Uncompresses a section that was compressed using zlib, in place.  */
13339
13340 static bfd_boolean
13341 uncompress_section_contents (unsigned char **   buffer,
13342                              dwarf_size_type    uncompressed_size,
13343                              dwarf_size_type *  size)
13344 {
13345   dwarf_size_type compressed_size = *size;
13346   unsigned char * compressed_buffer = *buffer;
13347   unsigned char * uncompressed_buffer;
13348   z_stream strm;
13349   int rc;
13350
13351   /* It is possible the section consists of several compressed
13352      buffers concatenated together, so we uncompress in a loop.  */
13353   /* PR 18313: The state field in the z_stream structure is supposed
13354      to be invisible to the user (ie us), but some compilers will
13355      still complain about it being used without initialisation.  So
13356      we first zero the entire z_stream structure and then set the fields
13357      that we need.  */
13358   memset (& strm, 0, sizeof strm);
13359   strm.avail_in = compressed_size;
13360   strm.next_in = (Bytef *) compressed_buffer;
13361   strm.avail_out = uncompressed_size;
13362   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13363
13364   rc = inflateInit (& strm);
13365   while (strm.avail_in > 0)
13366     {
13367       if (rc != Z_OK)
13368         goto fail;
13369       strm.next_out = ((Bytef *) uncompressed_buffer
13370                        + (uncompressed_size - strm.avail_out));
13371       rc = inflate (&strm, Z_FINISH);
13372       if (rc != Z_STREAM_END)
13373         goto fail;
13374       rc = inflateReset (& strm);
13375     }
13376   rc = inflateEnd (& strm);
13377   if (rc != Z_OK
13378       || strm.avail_out != 0)
13379     goto fail;
13380
13381   *buffer = uncompressed_buffer;
13382   *size = uncompressed_size;
13383   return TRUE;
13384
13385  fail:
13386   free (uncompressed_buffer);
13387   /* Indicate decompression failure.  */
13388   *buffer = NULL;
13389   return FALSE;
13390 }
13391
13392 static bfd_boolean
13393 dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13394 {
13395   Elf_Internal_Shdr *  relsec;
13396   bfd_size_type        num_bytes;
13397   unsigned char *      data;
13398   unsigned char *      end;
13399   unsigned char *      real_start;
13400   unsigned char *      start;
13401   bfd_boolean          some_strings_shown;
13402
13403   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13404   if (start == NULL)
13405     /* PR 21820: Do not fail if the section was empty.  */
13406     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13407
13408   num_bytes = section->sh_size;
13409
13410   printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13411
13412   if (decompress_dumps)
13413     {
13414       dwarf_size_type new_size = num_bytes;
13415       dwarf_size_type uncompressed_size = 0;
13416
13417       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13418         {
13419           Elf_Internal_Chdr chdr;
13420           unsigned int compression_header_size
13421             = get_compression_header (& chdr, (unsigned char *) start,
13422                                       num_bytes);
13423
13424           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13425             {
13426               warn (_("section '%s' has unsupported compress type: %d\n"),
13427                     printable_section_name (filedata, section), chdr.ch_type);
13428               return FALSE;
13429             }
13430           uncompressed_size = chdr.ch_size;
13431           start += compression_header_size;
13432           new_size -= compression_header_size;
13433         }
13434       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13435         {
13436           /* Read the zlib header.  In this case, it should be "ZLIB"
13437              followed by the uncompressed section size, 8 bytes in
13438              big-endian order.  */
13439           uncompressed_size = start[4]; uncompressed_size <<= 8;
13440           uncompressed_size += start[5]; uncompressed_size <<= 8;
13441           uncompressed_size += start[6]; uncompressed_size <<= 8;
13442           uncompressed_size += start[7]; uncompressed_size <<= 8;
13443           uncompressed_size += start[8]; uncompressed_size <<= 8;
13444           uncompressed_size += start[9]; uncompressed_size <<= 8;
13445           uncompressed_size += start[10]; uncompressed_size <<= 8;
13446           uncompressed_size += start[11];
13447           start += 12;
13448           new_size -= 12;
13449         }
13450
13451       if (uncompressed_size)
13452         {
13453           if (uncompress_section_contents (& start,
13454                                            uncompressed_size, & new_size))
13455             num_bytes = new_size;
13456           else
13457             {
13458               error (_("Unable to decompress section %s\n"),
13459                      printable_section_name (filedata, section));
13460               return FALSE;
13461             }
13462         }
13463       else
13464         start = real_start;
13465     }
13466
13467   /* If the section being dumped has relocations against it the user might
13468      be expecting these relocations to have been applied.  Check for this
13469      case and issue a warning message in order to avoid confusion.
13470      FIXME: Maybe we ought to have an option that dumps a section with
13471      relocs applied ?  */
13472   for (relsec = filedata->section_headers;
13473        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13474        ++relsec)
13475     {
13476       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13477           || relsec->sh_info >= filedata->file_header.e_shnum
13478           || filedata->section_headers + relsec->sh_info != section
13479           || relsec->sh_size == 0
13480           || relsec->sh_link >= filedata->file_header.e_shnum)
13481         continue;
13482
13483       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13484       break;
13485     }
13486
13487   data = start;
13488   end  = start + num_bytes;
13489   some_strings_shown = FALSE;
13490
13491   while (data < end)
13492     {
13493       while (!ISPRINT (* data))
13494         if (++ data >= end)
13495           break;
13496
13497       if (data < end)
13498         {
13499           size_t maxlen = end - data;
13500
13501 #ifndef __MSVCRT__
13502           /* PR 11128: Use two separate invocations in order to work
13503              around bugs in the Solaris 8 implementation of printf.  */
13504           printf ("  [%6tx]  ", data - start);
13505 #else
13506           printf ("  [%6Ix]  ", (size_t) (data - start));
13507 #endif
13508           if (maxlen > 0)
13509             {
13510               print_symbol ((int) maxlen, (const char *) data);
13511               putchar ('\n');
13512               data += strnlen ((const char *) data, maxlen);
13513             }
13514           else
13515             {
13516               printf (_("<corrupt>\n"));
13517               data = end;
13518             }
13519           some_strings_shown = TRUE;
13520         }
13521     }
13522
13523   if (! some_strings_shown)
13524     printf (_("  No strings found in this section."));
13525
13526   free (real_start);
13527
13528   putchar ('\n');
13529   return TRUE;
13530 }
13531
13532 static bfd_boolean
13533 dump_section_as_bytes (Elf_Internal_Shdr *  section,
13534                        Filedata *           filedata,
13535                        bfd_boolean          relocate)
13536 {
13537   Elf_Internal_Shdr * relsec;
13538   bfd_size_type       bytes;
13539   bfd_size_type       section_size;
13540   bfd_vma             addr;
13541   unsigned char *     data;
13542   unsigned char *     real_start;
13543   unsigned char *     start;
13544
13545   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13546   if (start == NULL)
13547     /* PR 21820: Do not fail if the section was empty.  */
13548     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13549
13550   section_size = section->sh_size;
13551
13552   printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13553
13554   if (decompress_dumps)
13555     {
13556       dwarf_size_type new_size = section_size;
13557       dwarf_size_type uncompressed_size = 0;
13558
13559       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13560         {
13561           Elf_Internal_Chdr chdr;
13562           unsigned int compression_header_size
13563             = get_compression_header (& chdr, start, section_size);
13564
13565           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13566             {
13567               warn (_("section '%s' has unsupported compress type: %d\n"),
13568                     printable_section_name (filedata, section), chdr.ch_type);
13569               return FALSE;
13570             }
13571           uncompressed_size = chdr.ch_size;
13572           start += compression_header_size;
13573           new_size -= compression_header_size;
13574         }
13575       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13576         {
13577           /* Read the zlib header.  In this case, it should be "ZLIB"
13578              followed by the uncompressed section size, 8 bytes in
13579              big-endian order.  */
13580           uncompressed_size = start[4]; uncompressed_size <<= 8;
13581           uncompressed_size += start[5]; uncompressed_size <<= 8;
13582           uncompressed_size += start[6]; uncompressed_size <<= 8;
13583           uncompressed_size += start[7]; uncompressed_size <<= 8;
13584           uncompressed_size += start[8]; uncompressed_size <<= 8;
13585           uncompressed_size += start[9]; uncompressed_size <<= 8;
13586           uncompressed_size += start[10]; uncompressed_size <<= 8;
13587           uncompressed_size += start[11];
13588           start += 12;
13589           new_size -= 12;
13590         }
13591
13592       if (uncompressed_size)
13593         {
13594           if (uncompress_section_contents (& start, uncompressed_size,
13595                                            & new_size))
13596             {
13597               section_size = new_size;
13598             }
13599           else
13600             {
13601               error (_("Unable to decompress section %s\n"),
13602                      printable_section_name (filedata, section));
13603               /* FIXME: Print the section anyway ?  */
13604               return FALSE;
13605             }
13606         }
13607       else
13608         start = real_start;
13609     }
13610
13611   if (relocate)
13612     {
13613       if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
13614         return FALSE;
13615     }
13616   else
13617     {
13618       /* If the section being dumped has relocations against it the user might
13619          be expecting these relocations to have been applied.  Check for this
13620          case and issue a warning message in order to avoid confusion.
13621          FIXME: Maybe we ought to have an option that dumps a section with
13622          relocs applied ?  */
13623       for (relsec = filedata->section_headers;
13624            relsec < filedata->section_headers + filedata->file_header.e_shnum;
13625            ++relsec)
13626         {
13627           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13628               || relsec->sh_info >= filedata->file_header.e_shnum
13629               || filedata->section_headers + relsec->sh_info != section
13630               || relsec->sh_size == 0
13631               || relsec->sh_link >= filedata->file_header.e_shnum)
13632             continue;
13633
13634           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13635           break;
13636         }
13637     }
13638
13639   addr = section->sh_addr;
13640   bytes = section_size;
13641   data = start;
13642
13643   while (bytes)
13644     {
13645       int j;
13646       int k;
13647       int lbytes;
13648
13649       lbytes = (bytes > 16 ? 16 : bytes);
13650
13651       printf ("  0x%8.8lx ", (unsigned long) addr);
13652
13653       for (j = 0; j < 16; j++)
13654         {
13655           if (j < lbytes)
13656             printf ("%2.2x", data[j]);
13657           else
13658             printf ("  ");
13659
13660           if ((j & 3) == 3)
13661             printf (" ");
13662         }
13663
13664       for (j = 0; j < lbytes; j++)
13665         {
13666           k = data[j];
13667           if (k >= ' ' && k < 0x7f)
13668             printf ("%c", k);
13669           else
13670             printf (".");
13671         }
13672
13673       putchar ('\n');
13674
13675       data  += lbytes;
13676       addr  += lbytes;
13677       bytes -= lbytes;
13678     }
13679
13680   free (real_start);
13681
13682   putchar ('\n');
13683   return TRUE;
13684 }
13685
13686 static bfd_boolean
13687 load_specific_debug_section (enum dwarf_section_display_enum  debug,
13688                              const Elf_Internal_Shdr *        sec,
13689                              void *                           data)
13690 {
13691   struct dwarf_section * section = &debug_displays [debug].section;
13692   char buf [64];
13693   Filedata * filedata = (Filedata *) data;
13694
13695   if (section->start != NULL)
13696     {
13697       /* If it is already loaded, do nothing.  */
13698       if (streq (section->filename, filedata->file_name))
13699         return TRUE;
13700       free (section->start);
13701     }
13702
13703   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13704   section->address = sec->sh_addr;
13705   section->user_data = NULL;
13706   section->filename = filedata->file_name;
13707   section->start = (unsigned char *) get_data (NULL, filedata,
13708                                                sec->sh_offset, 1,
13709                                                sec->sh_size, buf);
13710   if (section->start == NULL)
13711     section->size = 0;
13712   else
13713     {
13714       unsigned char *start = section->start;
13715       dwarf_size_type size = sec->sh_size;
13716       dwarf_size_type uncompressed_size = 0;
13717
13718       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13719         {
13720           Elf_Internal_Chdr chdr;
13721           unsigned int compression_header_size;
13722
13723           if (size < (is_32bit_elf
13724                       ? sizeof (Elf32_External_Chdr)
13725                       : sizeof (Elf64_External_Chdr)))
13726             {
13727               warn (_("compressed section %s is too small to contain a compression header"),
13728                     section->name);
13729               return FALSE;
13730             }
13731
13732           compression_header_size = get_compression_header (&chdr, start, size);
13733
13734           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13735             {
13736               warn (_("section '%s' has unsupported compress type: %d\n"),
13737                     section->name, chdr.ch_type);
13738               return FALSE;
13739             }
13740           uncompressed_size = chdr.ch_size;
13741           start += compression_header_size;
13742           size -= compression_header_size;
13743         }
13744       else if (size > 12 && streq ((char *) start, "ZLIB"))
13745         {
13746           /* Read the zlib header.  In this case, it should be "ZLIB"
13747              followed by the uncompressed section size, 8 bytes in
13748              big-endian order.  */
13749           uncompressed_size = start[4]; uncompressed_size <<= 8;
13750           uncompressed_size += start[5]; uncompressed_size <<= 8;
13751           uncompressed_size += start[6]; uncompressed_size <<= 8;
13752           uncompressed_size += start[7]; uncompressed_size <<= 8;
13753           uncompressed_size += start[8]; uncompressed_size <<= 8;
13754           uncompressed_size += start[9]; uncompressed_size <<= 8;
13755           uncompressed_size += start[10]; uncompressed_size <<= 8;
13756           uncompressed_size += start[11];
13757           start += 12;
13758           size -= 12;
13759         }
13760
13761       if (uncompressed_size)
13762         {
13763           if (uncompress_section_contents (&start, uncompressed_size,
13764                                            &size))
13765             {
13766               /* Free the compressed buffer, update the section buffer
13767                  and the section size if uncompress is successful.  */
13768               free (section->start);
13769               section->start = start;
13770             }
13771           else
13772             {
13773               error (_("Unable to decompress section %s\n"),
13774                      printable_section_name (filedata, sec));
13775               return FALSE;
13776             }
13777         }
13778
13779       section->size = size;
13780     }
13781
13782   if (section->start == NULL)
13783     return FALSE;
13784
13785   if (debug_displays [debug].relocate)
13786     {
13787       if (! apply_relocations (filedata, sec, section->start, section->size,
13788                                & section->reloc_info, & section->num_relocs))
13789         return FALSE;
13790     }
13791   else
13792     {
13793       section->reloc_info = NULL;
13794       section->num_relocs = 0;
13795     }
13796
13797   return TRUE;
13798 }
13799
13800 /* If this is not NULL, load_debug_section will only look for sections
13801    within the list of sections given here.  */
13802 static unsigned int * section_subset = NULL;
13803
13804 bfd_boolean
13805 load_debug_section (enum dwarf_section_display_enum debug, void * data)
13806 {
13807   struct dwarf_section * section = &debug_displays [debug].section;
13808   Elf_Internal_Shdr * sec;
13809   Filedata * filedata = (Filedata *) data;
13810
13811   /* Without section headers we cannot find any sections.  */
13812   if (filedata->section_headers == NULL)
13813     return FALSE;
13814
13815   if (filedata->string_table == NULL
13816       && filedata->file_header.e_shstrndx != SHN_UNDEF
13817       && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
13818     {
13819       Elf_Internal_Shdr * strs;
13820
13821       /* Read in the string table, so that we have section names to scan.  */
13822       strs = filedata->section_headers + filedata->file_header.e_shstrndx;
13823
13824       if (strs != NULL && strs->sh_size != 0)
13825         {
13826           filedata->string_table
13827             = (char *) get_data (NULL, filedata, strs->sh_offset,
13828                                  1, strs->sh_size, _("string table"));
13829
13830           filedata->string_table_length
13831             = filedata->string_table != NULL ? strs->sh_size : 0;
13832         }
13833     }
13834
13835   /* Locate the debug section.  */
13836   sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
13837   if (sec != NULL)
13838     section->name = section->uncompressed_name;
13839   else
13840     {
13841       sec = find_section_in_set (filedata, section->compressed_name, section_subset);
13842       if (sec != NULL)
13843         section->name = section->compressed_name;
13844     }
13845   if (sec == NULL)
13846     return FALSE;
13847
13848   /* If we're loading from a subset of sections, and we've loaded
13849      a section matching this name before, it's likely that it's a
13850      different one.  */
13851   if (section_subset != NULL)
13852     free_debug_section (debug);
13853
13854   return load_specific_debug_section (debug, sec, data);
13855 }
13856
13857 void
13858 free_debug_section (enum dwarf_section_display_enum debug)
13859 {
13860   struct dwarf_section * section = &debug_displays [debug].section;
13861
13862   if (section->start == NULL)
13863     return;
13864
13865   free ((char *) section->start);
13866   section->start = NULL;
13867   section->address = 0;
13868   section->size = 0;
13869 }
13870
13871 static bfd_boolean
13872 display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
13873 {
13874   char * name = SECTION_NAME (section);
13875   const char * print_name = printable_section_name (filedata, section);
13876   bfd_size_type length;
13877   bfd_boolean result = TRUE;
13878   int i;
13879
13880   length = section->sh_size;
13881   if (length == 0)
13882     {
13883       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13884       return TRUE;
13885     }
13886   if (section->sh_type == SHT_NOBITS)
13887     {
13888       /* There is no point in dumping the contents of a debugging section
13889          which has the NOBITS type - the bits in the file will be random.
13890          This can happen when a file containing a .eh_frame section is
13891          stripped with the --only-keep-debug command line option.  */
13892       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13893               print_name);
13894       return FALSE;
13895     }
13896
13897   if (const_strneq (name, ".gnu.linkonce.wi."))
13898     name = ".debug_info";
13899
13900   /* See if we know how to display the contents of this section.  */
13901   for (i = 0; i < max; i++)
13902     {
13903       enum dwarf_section_display_enum  id = (enum dwarf_section_display_enum) i;
13904       struct dwarf_section_display *   display = debug_displays + i;
13905       struct dwarf_section *           sec = & display->section;
13906
13907       if (streq (sec->uncompressed_name, name)
13908           || (id == line && const_strneq (name, ".debug_line."))
13909           || streq (sec->compressed_name, name))
13910         {
13911           bfd_boolean secondary = (section != find_section (filedata, name));
13912
13913           if (secondary)
13914             free_debug_section (id);
13915
13916           if (i == line && const_strneq (name, ".debug_line."))
13917             sec->name = name;
13918           else if (streq (sec->uncompressed_name, name))
13919             sec->name = sec->uncompressed_name;
13920           else
13921             sec->name = sec->compressed_name;
13922
13923           if (load_specific_debug_section (id, section, filedata))
13924             {
13925               /* If this debug section is part of a CU/TU set in a .dwp file,
13926                  restrict load_debug_section to the sections in that set.  */
13927               section_subset = find_cu_tu_set (filedata, shndx);
13928
13929               result &= display->display (sec, filedata);
13930
13931               section_subset = NULL;
13932
13933               if (secondary || (id != info && id != abbrev))
13934                 free_debug_section (id);
13935             }
13936           break;
13937         }
13938     }
13939
13940   if (i == max)
13941     {
13942       printf (_("Unrecognized debug section: %s\n"), print_name);
13943       result = FALSE;
13944     }
13945
13946   return result;
13947 }
13948
13949 /* Set DUMP_SECTS for all sections where dumps were requested
13950    based on section name.  */
13951
13952 static void
13953 initialise_dumps_byname (Filedata * filedata)
13954 {
13955   struct dump_list_entry * cur;
13956
13957   for (cur = dump_sects_byname; cur; cur = cur->next)
13958     {
13959       unsigned int i;
13960       bfd_boolean any = FALSE;
13961
13962       for (i = 0; i < filedata->file_header.e_shnum; i++)
13963         if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
13964           {
13965             request_dump_bynumber (filedata, i, cur->type);
13966             any = TRUE;
13967           }
13968
13969       if (!any)
13970         warn (_("Section '%s' was not dumped because it does not exist!\n"),
13971               cur->name);
13972     }
13973 }
13974
13975 static bfd_boolean
13976 process_section_contents (Filedata * filedata)
13977 {
13978   Elf_Internal_Shdr * section;
13979   unsigned int i;
13980   bfd_boolean res = TRUE;
13981
13982   if (! do_dump)
13983     return TRUE;
13984
13985   initialise_dumps_byname (filedata);
13986
13987   for (i = 0, section = filedata->section_headers;
13988        i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
13989        i++, section++)
13990     {
13991       dump_type dump = filedata->dump_sects[i];
13992
13993 #ifdef SUPPORT_DISASSEMBLY
13994       if (dump & DISASS_DUMP)
13995         {
13996           if (! disassemble_section (section, filedata))
13997             res = FALSE;
13998         }
13999 #endif
14000       if (dump & HEX_DUMP)
14001         {
14002           if (! dump_section_as_bytes (section, filedata, FALSE))
14003             res = FALSE;
14004         }
14005
14006       if (dump & RELOC_DUMP)
14007         {
14008           if (! dump_section_as_bytes (section, filedata, TRUE))
14009             res = FALSE;
14010         }
14011
14012       if (dump & STRING_DUMP)
14013         {
14014           if (! dump_section_as_strings (section, filedata))
14015             res = FALSE;
14016         }
14017
14018       if (dump & DEBUG_DUMP)
14019         {
14020           if (! display_debug_section (i, section, filedata))
14021             res = FALSE;
14022         }
14023     }
14024
14025   /* Check to see if the user requested a
14026      dump of a section that does not exist.  */
14027   while (i < filedata->num_dump_sects)
14028     {
14029       if (filedata->dump_sects[i])
14030         {
14031           warn (_("Section %d was not dumped because it does not exist!\n"), i);
14032           res = FALSE;
14033         }
14034       i++;
14035     }
14036
14037   return res;
14038 }
14039
14040 static void
14041 process_mips_fpe_exception (int mask)
14042 {
14043   if (mask)
14044     {
14045       bfd_boolean first = TRUE;
14046
14047       if (mask & OEX_FPU_INEX)
14048         fputs ("INEX", stdout), first = FALSE;
14049       if (mask & OEX_FPU_UFLO)
14050         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
14051       if (mask & OEX_FPU_OFLO)
14052         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
14053       if (mask & OEX_FPU_DIV0)
14054         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
14055       if (mask & OEX_FPU_INVAL)
14056         printf ("%sINVAL", first ? "" : "|");
14057     }
14058   else
14059     fputs ("0", stdout);
14060 }
14061
14062 /* Display's the value of TAG at location P.  If TAG is
14063    greater than 0 it is assumed to be an unknown tag, and
14064    a message is printed to this effect.  Otherwise it is
14065    assumed that a message has already been printed.
14066
14067    If the bottom bit of TAG is set it assumed to have a
14068    string value, otherwise it is assumed to have an integer
14069    value.
14070
14071    Returns an updated P pointing to the first unread byte
14072    beyond the end of TAG's value.
14073
14074    Reads at or beyond END will not be made.  */
14075
14076 static unsigned char *
14077 display_tag_value (signed int tag,
14078                    unsigned char * p,
14079                    const unsigned char * const end)
14080 {
14081   unsigned long val;
14082
14083   if (tag > 0)
14084     printf ("  Tag_unknown_%d: ", tag);
14085
14086   if (p >= end)
14087     {
14088       warn (_("<corrupt tag>\n"));
14089     }
14090   else if (tag & 1)
14091     {
14092       /* PR 17531 file: 027-19978-0.004.  */
14093       size_t maxlen = (end - p) - 1;
14094
14095       putchar ('"');
14096       if (maxlen > 0)
14097         {
14098           print_symbol ((int) maxlen, (const char *) p);
14099           p += strnlen ((char *) p, maxlen) + 1;
14100         }
14101       else
14102         {
14103           printf (_("<corrupt string tag>"));
14104           p = (unsigned char *) end;
14105         }
14106       printf ("\"\n");
14107     }
14108   else
14109     {
14110       unsigned int len;
14111
14112       val = read_uleb128 (p, &len, end);
14113       p += len;
14114       printf ("%ld (0x%lx)\n", val, val);
14115     }
14116
14117   assert (p <= end);
14118   return p;
14119 }
14120
14121 /* ARC ABI attributes section.  */
14122
14123 static unsigned char *
14124 display_arc_attribute (unsigned char * p,
14125                        const unsigned char * const end)
14126 {
14127   unsigned int tag;
14128   unsigned int len;
14129   unsigned int val;
14130
14131   tag = read_uleb128 (p, &len, end);
14132   p += len;
14133
14134   switch (tag)
14135     {
14136     case Tag_ARC_PCS_config:
14137       val = read_uleb128 (p, &len, end);
14138       p += len;
14139       printf ("  Tag_ARC_PCS_config: ");
14140       switch (val)
14141         {
14142         case 0:
14143           printf (_("Absent/Non standard\n"));
14144           break;
14145         case 1:
14146           printf (_("Bare metal/mwdt\n"));
14147           break;
14148         case 2:
14149           printf (_("Bare metal/newlib\n"));
14150           break;
14151         case 3:
14152           printf (_("Linux/uclibc\n"));
14153           break;
14154         case 4:
14155           printf (_("Linux/glibc\n"));
14156           break;
14157         default:
14158           printf (_("Unknown\n"));
14159           break;
14160         }
14161       break;
14162
14163     case Tag_ARC_CPU_base:
14164       val = read_uleb128 (p, &len, end);
14165       p += len;
14166       printf ("  Tag_ARC_CPU_base: ");
14167       switch (val)
14168         {
14169         default:
14170         case TAG_CPU_NONE:
14171           printf (_("Absent\n"));
14172           break;
14173         case TAG_CPU_ARC6xx:
14174           printf ("ARC6xx\n");
14175           break;
14176         case TAG_CPU_ARC7xx:
14177           printf ("ARC7xx\n");
14178           break;
14179         case TAG_CPU_ARCEM:
14180           printf ("ARCEM\n");
14181           break;
14182         case TAG_CPU_ARCHS:
14183           printf ("ARCHS\n");
14184           break;
14185         }
14186       break;
14187
14188     case Tag_ARC_CPU_variation:
14189       val = read_uleb128 (p, &len, end);
14190       p += len;
14191       printf ("  Tag_ARC_CPU_variation: ");
14192       switch (val)
14193         {
14194         default:
14195           if (val > 0 && val < 16)
14196               printf ("Core%d\n", val);
14197           else
14198               printf ("Unknown\n");
14199           break;
14200
14201         case 0:
14202           printf (_("Absent\n"));
14203           break;
14204         }
14205       break;
14206
14207     case Tag_ARC_CPU_name:
14208       printf ("  Tag_ARC_CPU_name: ");
14209       p = display_tag_value (-1, p, end);
14210       break;
14211
14212     case Tag_ARC_ABI_rf16:
14213       val = read_uleb128 (p, &len, end);
14214       p += len;
14215       printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
14216       break;
14217
14218     case Tag_ARC_ABI_osver:
14219       val = read_uleb128 (p, &len, end);
14220       p += len;
14221       printf ("  Tag_ARC_ABI_osver: v%d\n", val);
14222       break;
14223
14224     case Tag_ARC_ABI_pic:
14225     case Tag_ARC_ABI_sda:
14226       val = read_uleb128 (p, &len, end);
14227       p += len;
14228       printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
14229               : "  Tag_ARC_ABI_pic: ");
14230       switch (val)
14231         {
14232         case 0:
14233           printf (_("Absent\n"));
14234           break;
14235         case 1:
14236           printf ("MWDT\n");
14237           break;
14238         case 2:
14239           printf ("GNU\n");
14240           break;
14241         default:
14242           printf (_("Unknown\n"));
14243           break;
14244         }
14245       break;
14246
14247     case Tag_ARC_ABI_tls:
14248       val = read_uleb128 (p, &len, end);
14249       p += len;
14250       printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14251       break;
14252
14253     case Tag_ARC_ABI_enumsize:
14254       val = read_uleb128 (p, &len, end);
14255       p += len;
14256       printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14257               _("smallest"));
14258       break;
14259
14260     case Tag_ARC_ABI_exceptions:
14261       val = read_uleb128 (p, &len, end);
14262       p += len;
14263       printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14264               : _("default"));
14265       break;
14266
14267     case Tag_ARC_ABI_double_size:
14268       val = read_uleb128 (p, &len, end);
14269       p += len;
14270       printf ("  Tag_ARC_ABI_double_size: %d\n", val);
14271       break;
14272
14273     case Tag_ARC_ISA_config:
14274       printf ("  Tag_ARC_ISA_config: ");
14275       p = display_tag_value (-1, p, end);
14276       break;
14277
14278     case Tag_ARC_ISA_apex:
14279       printf ("  Tag_ARC_ISA_apex: ");
14280       p = display_tag_value (-1, p, end);
14281       break;
14282
14283     case Tag_ARC_ISA_mpy_option:
14284       val = read_uleb128 (p, &len, end);
14285       p += len;
14286       printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
14287       break;
14288
14289     case Tag_ARC_ATR_version:
14290       val = read_uleb128 (p, &len, end);
14291       p += len;
14292       printf ("  Tag_ARC_ATR_version: %d\n", val);
14293       break;
14294
14295     default:
14296       return display_tag_value (tag & 1, p, end);
14297     }
14298
14299   return p;
14300 }
14301
14302 /* ARM EABI attributes section.  */
14303 typedef struct
14304 {
14305   unsigned int tag;
14306   const char * name;
14307   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
14308   unsigned int type;
14309   const char ** table;
14310 } arm_attr_public_tag;
14311
14312 static const char * arm_attr_tag_CPU_arch[] =
14313   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14314    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14315    "v8-M.mainline"};
14316 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14317 static const char * arm_attr_tag_THUMB_ISA_use[] =
14318   {"No", "Thumb-1", "Thumb-2", "Yes"};
14319 static const char * arm_attr_tag_FP_arch[] =
14320   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14321    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14322 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14323 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14324   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14325    "NEON for ARMv8.1"};
14326 static const char * arm_attr_tag_PCS_config[] =
14327   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14328    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14329 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14330   {"V6", "SB", "TLS", "Unused"};
14331 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14332   {"Absolute", "PC-relative", "SB-relative", "None"};
14333 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14334   {"Absolute", "PC-relative", "None"};
14335 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14336   {"None", "direct", "GOT-indirect"};
14337 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14338   {"None", "??? 1", "2", "??? 3", "4"};
14339 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14340 static const char * arm_attr_tag_ABI_FP_denormal[] =
14341   {"Unused", "Needed", "Sign only"};
14342 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14343 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14344 static const char * arm_attr_tag_ABI_FP_number_model[] =
14345   {"Unused", "Finite", "RTABI", "IEEE 754"};
14346 static const char * arm_attr_tag_ABI_enum_size[] =
14347   {"Unused", "small", "int", "forced to int"};
14348 static const char * arm_attr_tag_ABI_HardFP_use[] =
14349   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14350 static const char * arm_attr_tag_ABI_VFP_args[] =
14351   {"AAPCS", "VFP registers", "custom", "compatible"};
14352 static const char * arm_attr_tag_ABI_WMMX_args[] =
14353   {"AAPCS", "WMMX registers", "custom"};
14354 static const char * arm_attr_tag_ABI_optimization_goals[] =
14355   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14356     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14357 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14358   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14359     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14360 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14361 static const char * arm_attr_tag_FP_HP_extension[] =
14362   {"Not Allowed", "Allowed"};
14363 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14364   {"None", "IEEE 754", "Alternative Format"};
14365 static const char * arm_attr_tag_DSP_extension[] =
14366   {"Follow architecture", "Allowed"};
14367 static const char * arm_attr_tag_MPextension_use[] =
14368   {"Not Allowed", "Allowed"};
14369 static const char * arm_attr_tag_DIV_use[] =
14370   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14371     "Allowed in v7-A with integer division extension"};
14372 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14373 static const char * arm_attr_tag_Virtualization_use[] =
14374   {"Not Allowed", "TrustZone", "Virtualization Extensions",
14375     "TrustZone and Virtualization Extensions"};
14376 static const char * arm_attr_tag_MPextension_use_legacy[] =
14377   {"Not Allowed", "Allowed"};
14378
14379 #define LOOKUP(id, name) \
14380   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14381 static arm_attr_public_tag arm_attr_public_tags[] =
14382 {
14383   {4, "CPU_raw_name", 1, NULL},
14384   {5, "CPU_name", 1, NULL},
14385   LOOKUP(6, CPU_arch),
14386   {7, "CPU_arch_profile", 0, NULL},
14387   LOOKUP(8, ARM_ISA_use),
14388   LOOKUP(9, THUMB_ISA_use),
14389   LOOKUP(10, FP_arch),
14390   LOOKUP(11, WMMX_arch),
14391   LOOKUP(12, Advanced_SIMD_arch),
14392   LOOKUP(13, PCS_config),
14393   LOOKUP(14, ABI_PCS_R9_use),
14394   LOOKUP(15, ABI_PCS_RW_data),
14395   LOOKUP(16, ABI_PCS_RO_data),
14396   LOOKUP(17, ABI_PCS_GOT_use),
14397   LOOKUP(18, ABI_PCS_wchar_t),
14398   LOOKUP(19, ABI_FP_rounding),
14399   LOOKUP(20, ABI_FP_denormal),
14400   LOOKUP(21, ABI_FP_exceptions),
14401   LOOKUP(22, ABI_FP_user_exceptions),
14402   LOOKUP(23, ABI_FP_number_model),
14403   {24, "ABI_align_needed", 0, NULL},
14404   {25, "ABI_align_preserved", 0, NULL},
14405   LOOKUP(26, ABI_enum_size),
14406   LOOKUP(27, ABI_HardFP_use),
14407   LOOKUP(28, ABI_VFP_args),
14408   LOOKUP(29, ABI_WMMX_args),
14409   LOOKUP(30, ABI_optimization_goals),
14410   LOOKUP(31, ABI_FP_optimization_goals),
14411   {32, "compatibility", 0, NULL},
14412   LOOKUP(34, CPU_unaligned_access),
14413   LOOKUP(36, FP_HP_extension),
14414   LOOKUP(38, ABI_FP_16bit_format),
14415   LOOKUP(42, MPextension_use),
14416   LOOKUP(44, DIV_use),
14417   LOOKUP(46, DSP_extension),
14418   {64, "nodefaults", 0, NULL},
14419   {65, "also_compatible_with", 0, NULL},
14420   LOOKUP(66, T2EE_use),
14421   {67, "conformance", 1, NULL},
14422   LOOKUP(68, Virtualization_use),
14423   LOOKUP(70, MPextension_use_legacy)
14424 };
14425 #undef LOOKUP
14426
14427 static unsigned char *
14428 display_arm_attribute (unsigned char * p,
14429                        const unsigned char * const end)
14430 {
14431   unsigned int tag;
14432   unsigned int len;
14433   unsigned int val;
14434   arm_attr_public_tag * attr;
14435   unsigned i;
14436   unsigned int type;
14437
14438   tag = read_uleb128 (p, &len, end);
14439   p += len;
14440   attr = NULL;
14441   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14442     {
14443       if (arm_attr_public_tags[i].tag == tag)
14444         {
14445           attr = &arm_attr_public_tags[i];
14446           break;
14447         }
14448     }
14449
14450   if (attr)
14451     {
14452       printf ("  Tag_%s: ", attr->name);
14453       switch (attr->type)
14454         {
14455         case 0:
14456           switch (tag)
14457             {
14458             case 7: /* Tag_CPU_arch_profile.  */
14459               val = read_uleb128 (p, &len, end);
14460               p += len;
14461               switch (val)
14462                 {
14463                 case 0: printf (_("None\n")); break;
14464                 case 'A': printf (_("Application\n")); break;
14465                 case 'R': printf (_("Realtime\n")); break;
14466                 case 'M': printf (_("Microcontroller\n")); break;
14467                 case 'S': printf (_("Application or Realtime\n")); break;
14468                 default: printf ("??? (%d)\n", val); break;
14469                 }
14470               break;
14471
14472             case 24: /* Tag_align_needed.  */
14473               val = read_uleb128 (p, &len, end);
14474               p += len;
14475               switch (val)
14476                 {
14477                 case 0: printf (_("None\n")); break;
14478                 case 1: printf (_("8-byte\n")); break;
14479                 case 2: printf (_("4-byte\n")); break;
14480                 case 3: printf ("??? 3\n"); break;
14481                 default:
14482                   if (val <= 12)
14483                     printf (_("8-byte and up to %d-byte extended\n"),
14484                             1 << val);
14485                   else
14486                     printf ("??? (%d)\n", val);
14487                   break;
14488                 }
14489               break;
14490
14491             case 25: /* Tag_align_preserved.  */
14492               val = read_uleb128 (p, &len, end);
14493               p += len;
14494               switch (val)
14495                 {
14496                 case 0: printf (_("None\n")); break;
14497                 case 1: printf (_("8-byte, except leaf SP\n")); break;
14498                 case 2: printf (_("8-byte\n")); break;
14499                 case 3: printf ("??? 3\n"); break;
14500                 default:
14501                   if (val <= 12)
14502                     printf (_("8-byte and up to %d-byte extended\n"),
14503                             1 << val);
14504                   else
14505                     printf ("??? (%d)\n", val);
14506                   break;
14507                 }
14508               break;
14509
14510             case 32: /* Tag_compatibility.  */
14511               {
14512                 val = read_uleb128 (p, &len, end);
14513                 p += len;
14514                 printf (_("flag = %d, vendor = "), val);
14515                 if (p < end - 1)
14516                   {
14517                     size_t maxlen = (end - p) - 1;
14518
14519                     print_symbol ((int) maxlen, (const char *) p);
14520                     p += strnlen ((char *) p, maxlen) + 1;
14521                   }
14522                 else
14523                   {
14524                     printf (_("<corrupt>"));
14525                     p = (unsigned char *) end;
14526                   }
14527                 putchar ('\n');
14528               }
14529               break;
14530
14531             case 64: /* Tag_nodefaults.  */
14532               /* PR 17531: file: 001-505008-0.01.  */
14533               if (p < end)
14534                 p++;
14535               printf (_("True\n"));
14536               break;
14537
14538             case 65: /* Tag_also_compatible_with.  */
14539               val = read_uleb128 (p, &len, end);
14540               p += len;
14541               if (val == 6 /* Tag_CPU_arch.  */)
14542                 {
14543                   val = read_uleb128 (p, &len, end);
14544                   p += len;
14545                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14546                     printf ("??? (%d)\n", val);
14547                   else
14548                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14549                 }
14550               else
14551                 printf ("???\n");
14552               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
14553                 ;
14554               break;
14555
14556             default:
14557               printf (_("<unknown: %d>\n"), tag);
14558               break;
14559             }
14560           return p;
14561
14562         case 1:
14563           return display_tag_value (-1, p, end);
14564         case 2:
14565           return display_tag_value (0, p, end);
14566
14567         default:
14568           assert (attr->type & 0x80);
14569           val = read_uleb128 (p, &len, end);
14570           p += len;
14571           type = attr->type & 0x7f;
14572           if (val >= type)
14573             printf ("??? (%d)\n", val);
14574           else
14575             printf ("%s\n", attr->table[val]);
14576           return p;
14577         }
14578     }
14579
14580   return display_tag_value (tag, p, end);
14581 }
14582
14583 static unsigned char *
14584 display_gnu_attribute (unsigned char * p,
14585                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14586                        const unsigned char * const end)
14587 {
14588   int tag;
14589   unsigned int len;
14590   unsigned int val;
14591
14592   tag = read_uleb128 (p, &len, end);
14593   p += len;
14594
14595   /* Tag_compatibility is the only generic GNU attribute defined at
14596      present.  */
14597   if (tag == 32)
14598     {
14599       val = read_uleb128 (p, &len, end);
14600       p += len;
14601
14602       printf (_("flag = %d, vendor = "), val);
14603       if (p == end)
14604         {
14605           printf (_("<corrupt>\n"));
14606           warn (_("corrupt vendor attribute\n"));
14607         }
14608       else
14609         {
14610           if (p < end - 1)
14611             {
14612               size_t maxlen = (end - p) - 1;
14613
14614               print_symbol ((int) maxlen, (const char *) p);
14615               p += strnlen ((char *) p, maxlen) + 1;
14616             }
14617           else
14618             {
14619               printf (_("<corrupt>"));
14620               p = (unsigned char *) end;
14621             }
14622           putchar ('\n');
14623         }
14624       return p;
14625     }
14626
14627   if ((tag & 2) == 0 && display_proc_gnu_attribute)
14628     return display_proc_gnu_attribute (p, tag, end);
14629
14630   return display_tag_value (tag, p, end);
14631 }
14632
14633 static unsigned char *
14634 display_power_gnu_attribute (unsigned char * p,
14635                              unsigned int tag,
14636                              const unsigned char * const end)
14637 {
14638   unsigned int len;
14639   unsigned int val;
14640
14641   if (tag == Tag_GNU_Power_ABI_FP)
14642     {
14643       val = read_uleb128 (p, &len, end);
14644       p += len;
14645       printf ("  Tag_GNU_Power_ABI_FP: ");
14646       if (len == 0)
14647         {
14648           printf (_("<corrupt>\n"));
14649           return p;
14650         }
14651
14652       if (val > 15)
14653         printf ("(%#x), ", val);
14654
14655       switch (val & 3)
14656         {
14657         case 0:
14658           printf (_("unspecified hard/soft float, "));
14659           break;
14660         case 1:
14661           printf (_("hard float, "));
14662           break;
14663         case 2:
14664           printf (_("soft float, "));
14665           break;
14666         case 3:
14667           printf (_("single-precision hard float, "));
14668           break;
14669         }
14670
14671       switch (val & 0xC)
14672         {
14673         case 0:
14674           printf (_("unspecified long double\n"));
14675           break;
14676         case 4:
14677           printf (_("128-bit IBM long double\n"));
14678           break;
14679         case 8:
14680           printf (_("64-bit long double\n"));
14681           break;
14682         case 12:
14683           printf (_("128-bit IEEE long double\n"));
14684           break;
14685         }
14686       return p;
14687     }
14688
14689   if (tag == Tag_GNU_Power_ABI_Vector)
14690     {
14691       val = read_uleb128 (p, &len, end);
14692       p += len;
14693       printf ("  Tag_GNU_Power_ABI_Vector: ");
14694       if (len == 0)
14695         {
14696           printf (_("<corrupt>\n"));
14697           return p;
14698         }
14699
14700       if (val > 3)
14701         printf ("(%#x), ", val);
14702
14703       switch (val & 3)
14704         {
14705         case 0:
14706           printf (_("unspecified\n"));
14707           break;
14708         case 1:
14709           printf (_("generic\n"));
14710           break;
14711         case 2:
14712           printf ("AltiVec\n");
14713           break;
14714         case 3:
14715           printf ("SPE\n");
14716           break;
14717         }
14718       return p;
14719     }
14720
14721   if (tag == Tag_GNU_Power_ABI_Struct_Return)
14722     {
14723       val = read_uleb128 (p, &len, end);
14724       p += len;
14725       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
14726       if (len == 0)
14727         {
14728           printf (_("<corrupt>\n"));
14729           return p;
14730         }
14731
14732       if (val > 2)
14733         printf ("(%#x), ", val);
14734
14735       switch (val & 3)
14736         {
14737         case 0:
14738           printf (_("unspecified\n"));
14739           break;
14740         case 1:
14741           printf ("r3/r4\n");
14742           break;
14743         case 2:
14744           printf (_("memory\n"));
14745           break;
14746         case 3:
14747           printf ("???\n");
14748           break;
14749         }
14750       return p;
14751     }
14752
14753   return display_tag_value (tag & 1, p, end);
14754 }
14755
14756 static unsigned char *
14757 display_s390_gnu_attribute (unsigned char * p,
14758                             unsigned int tag,
14759                             const unsigned char * const end)
14760 {
14761   unsigned int len;
14762   int val;
14763
14764   if (tag == Tag_GNU_S390_ABI_Vector)
14765     {
14766       val = read_uleb128 (p, &len, end);
14767       p += len;
14768       printf ("  Tag_GNU_S390_ABI_Vector: ");
14769
14770       switch (val)
14771         {
14772         case 0:
14773           printf (_("any\n"));
14774           break;
14775         case 1:
14776           printf (_("software\n"));
14777           break;
14778         case 2:
14779           printf (_("hardware\n"));
14780           break;
14781         default:
14782           printf ("??? (%d)\n", val);
14783           break;
14784         }
14785       return p;
14786    }
14787
14788   return display_tag_value (tag & 1, p, end);
14789 }
14790
14791 static void
14792 display_sparc_hwcaps (unsigned int mask)
14793 {
14794   if (mask)
14795     {
14796       bfd_boolean first = TRUE;
14797
14798       if (mask & ELF_SPARC_HWCAP_MUL32)
14799         fputs ("mul32", stdout), first = FALSE;
14800       if (mask & ELF_SPARC_HWCAP_DIV32)
14801         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14802       if (mask & ELF_SPARC_HWCAP_FSMULD)
14803         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14804       if (mask & ELF_SPARC_HWCAP_V8PLUS)
14805         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14806       if (mask & ELF_SPARC_HWCAP_POPC)
14807         printf ("%spopc", first ? "" : "|"), first = FALSE;
14808       if (mask & ELF_SPARC_HWCAP_VIS)
14809         printf ("%svis", first ? "" : "|"), first = FALSE;
14810       if (mask & ELF_SPARC_HWCAP_VIS2)
14811         printf ("%svis2", first ? "" : "|"), first = FALSE;
14812       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14813         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14814       if (mask & ELF_SPARC_HWCAP_FMAF)
14815         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14816       if (mask & ELF_SPARC_HWCAP_VIS3)
14817         printf ("%svis3", first ? "" : "|"), first = FALSE;
14818       if (mask & ELF_SPARC_HWCAP_HPC)
14819         printf ("%shpc", first ? "" : "|"), first = FALSE;
14820       if (mask & ELF_SPARC_HWCAP_RANDOM)
14821         printf ("%srandom", first ? "" : "|"), first = FALSE;
14822       if (mask & ELF_SPARC_HWCAP_TRANS)
14823         printf ("%strans", first ? "" : "|"), first = FALSE;
14824       if (mask & ELF_SPARC_HWCAP_FJFMAU)
14825         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14826       if (mask & ELF_SPARC_HWCAP_IMA)
14827         printf ("%sima", first ? "" : "|"), first = FALSE;
14828       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14829         printf ("%scspare", first ? "" : "|"), first = FALSE;
14830     }
14831   else
14832     fputc ('0', stdout);
14833   fputc ('\n', stdout);
14834 }
14835
14836 static void
14837 display_sparc_hwcaps2 (unsigned int mask)
14838 {
14839   if (mask)
14840     {
14841       bfd_boolean first = TRUE;
14842
14843       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14844         fputs ("fjathplus", stdout), first = FALSE;
14845       if (mask & ELF_SPARC_HWCAP2_VIS3B)
14846         printf ("%svis3b", first ? "" : "|"), first = FALSE;
14847       if (mask & ELF_SPARC_HWCAP2_ADP)
14848         printf ("%sadp", first ? "" : "|"), first = FALSE;
14849       if (mask & ELF_SPARC_HWCAP2_SPARC5)
14850         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14851       if (mask & ELF_SPARC_HWCAP2_MWAIT)
14852         printf ("%smwait", first ? "" : "|"), first = FALSE;
14853       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14854         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14855       if (mask & ELF_SPARC_HWCAP2_XMONT)
14856         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14857       if (mask & ELF_SPARC_HWCAP2_NSEC)
14858         printf ("%snsec", first ? "" : "|"), first = FALSE;
14859       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14860         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14861       if (mask & ELF_SPARC_HWCAP2_FJDES)
14862         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14863       if (mask & ELF_SPARC_HWCAP2_FJAES)
14864         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14865     }
14866   else
14867     fputc ('0', stdout);
14868   fputc ('\n', stdout);
14869 }
14870
14871 static unsigned char *
14872 display_sparc_gnu_attribute (unsigned char * p,
14873                              unsigned int tag,
14874                              const unsigned char * const end)
14875 {
14876   unsigned int len;
14877   int val;
14878
14879   if (tag == Tag_GNU_Sparc_HWCAPS)
14880     {
14881       val = read_uleb128 (p, &len, end);
14882       p += len;
14883       printf ("  Tag_GNU_Sparc_HWCAPS: ");
14884       display_sparc_hwcaps (val);
14885       return p;
14886     }
14887   if (tag == Tag_GNU_Sparc_HWCAPS2)
14888     {
14889       val = read_uleb128 (p, &len, end);
14890       p += len;
14891       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
14892       display_sparc_hwcaps2 (val);
14893       return p;
14894     }
14895
14896   return display_tag_value (tag, p, end);
14897 }
14898
14899 static void
14900 print_mips_fp_abi_value (unsigned int val)
14901 {
14902   switch (val)
14903     {
14904     case Val_GNU_MIPS_ABI_FP_ANY:
14905       printf (_("Hard or soft float\n"));
14906       break;
14907     case Val_GNU_MIPS_ABI_FP_DOUBLE:
14908       printf (_("Hard float (double precision)\n"));
14909       break;
14910     case Val_GNU_MIPS_ABI_FP_SINGLE:
14911       printf (_("Hard float (single precision)\n"));
14912       break;
14913     case Val_GNU_MIPS_ABI_FP_SOFT:
14914       printf (_("Soft float\n"));
14915       break;
14916     case Val_GNU_MIPS_ABI_FP_OLD_64:
14917       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14918       break;
14919     case Val_GNU_MIPS_ABI_FP_XX:
14920       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14921       break;
14922     case Val_GNU_MIPS_ABI_FP_64:
14923       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14924       break;
14925     case Val_GNU_MIPS_ABI_FP_64A:
14926       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14927       break;
14928     case Val_GNU_MIPS_ABI_FP_NAN2008:
14929       printf (_("NaN 2008 compatibility\n"));
14930       break;
14931     default:
14932       printf ("??? (%d)\n", val);
14933       break;
14934     }
14935 }
14936
14937 static unsigned char *
14938 display_mips_gnu_attribute (unsigned char * p,
14939                             unsigned int tag,
14940                             const unsigned char * const end)
14941 {
14942   if (tag == Tag_GNU_MIPS_ABI_FP)
14943     {
14944       unsigned int len;
14945       unsigned int val;
14946
14947       val = read_uleb128 (p, &len, end);
14948       p += len;
14949       printf ("  Tag_GNU_MIPS_ABI_FP: ");
14950
14951       print_mips_fp_abi_value (val);
14952
14953       return p;
14954    }
14955
14956   if (tag == Tag_GNU_MIPS_ABI_MSA)
14957     {
14958       unsigned int len;
14959       unsigned int val;
14960
14961       val = read_uleb128 (p, &len, end);
14962       p += len;
14963       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
14964
14965       switch (val)
14966         {
14967         case Val_GNU_MIPS_ABI_MSA_ANY:
14968           printf (_("Any MSA or not\n"));
14969           break;
14970         case Val_GNU_MIPS_ABI_MSA_128:
14971           printf (_("128-bit MSA\n"));
14972           break;
14973         default:
14974           printf ("??? (%d)\n", val);
14975           break;
14976         }
14977       return p;
14978     }
14979
14980   return display_tag_value (tag & 1, p, end);
14981 }
14982
14983 static unsigned char *
14984 display_tic6x_attribute (unsigned char * p,
14985                          const unsigned char * const end)
14986 {
14987   unsigned int tag;
14988   unsigned int len;
14989   int val;
14990
14991   tag = read_uleb128 (p, &len, end);
14992   p += len;
14993
14994   switch (tag)
14995     {
14996     case Tag_ISA:
14997       val = read_uleb128 (p, &len, end);
14998       p += len;
14999       printf ("  Tag_ISA: ");
15000
15001       switch (val)
15002         {
15003         case C6XABI_Tag_ISA_none:
15004           printf (_("None\n"));
15005           break;
15006         case C6XABI_Tag_ISA_C62X:
15007           printf ("C62x\n");
15008           break;
15009         case C6XABI_Tag_ISA_C67X:
15010           printf ("C67x\n");
15011           break;
15012         case C6XABI_Tag_ISA_C67XP:
15013           printf ("C67x+\n");
15014           break;
15015         case C6XABI_Tag_ISA_C64X:
15016           printf ("C64x\n");
15017           break;
15018         case C6XABI_Tag_ISA_C64XP:
15019           printf ("C64x+\n");
15020           break;
15021         case C6XABI_Tag_ISA_C674X:
15022           printf ("C674x\n");
15023           break;
15024         default:
15025           printf ("??? (%d)\n", val);
15026           break;
15027         }
15028       return p;
15029
15030     case Tag_ABI_wchar_t:
15031       val = read_uleb128 (p, &len, end);
15032       p += len;
15033       printf ("  Tag_ABI_wchar_t: ");
15034       switch (val)
15035         {
15036         case 0:
15037           printf (_("Not used\n"));
15038           break;
15039         case 1:
15040           printf (_("2 bytes\n"));
15041           break;
15042         case 2:
15043           printf (_("4 bytes\n"));
15044           break;
15045         default:
15046           printf ("??? (%d)\n", val);
15047           break;
15048         }
15049       return p;
15050
15051     case Tag_ABI_stack_align_needed:
15052       val = read_uleb128 (p, &len, end);
15053       p += len;
15054       printf ("  Tag_ABI_stack_align_needed: ");
15055       switch (val)
15056         {
15057         case 0:
15058           printf (_("8-byte\n"));
15059           break;
15060         case 1:
15061           printf (_("16-byte\n"));
15062           break;
15063         default:
15064           printf ("??? (%d)\n", val);
15065           break;
15066         }
15067       return p;
15068
15069     case Tag_ABI_stack_align_preserved:
15070       val = read_uleb128 (p, &len, end);
15071       p += len;
15072       printf ("  Tag_ABI_stack_align_preserved: ");
15073       switch (val)
15074         {
15075         case 0:
15076           printf (_("8-byte\n"));
15077           break;
15078         case 1:
15079           printf (_("16-byte\n"));
15080           break;
15081         default:
15082           printf ("??? (%d)\n", val);
15083           break;
15084         }
15085       return p;
15086
15087     case Tag_ABI_DSBT:
15088       val = read_uleb128 (p, &len, end);
15089       p += len;
15090       printf ("  Tag_ABI_DSBT: ");
15091       switch (val)
15092         {
15093         case 0:
15094           printf (_("DSBT addressing not used\n"));
15095           break;
15096         case 1:
15097           printf (_("DSBT addressing used\n"));
15098           break;
15099         default:
15100           printf ("??? (%d)\n", val);
15101           break;
15102         }
15103       return p;
15104
15105     case Tag_ABI_PID:
15106       val = read_uleb128 (p, &len, end);
15107       p += len;
15108       printf ("  Tag_ABI_PID: ");
15109       switch (val)
15110         {
15111         case 0:
15112           printf (_("Data addressing position-dependent\n"));
15113           break;
15114         case 1:
15115           printf (_("Data addressing position-independent, GOT near DP\n"));
15116           break;
15117         case 2:
15118           printf (_("Data addressing position-independent, GOT far from DP\n"));
15119           break;
15120         default:
15121           printf ("??? (%d)\n", val);
15122           break;
15123         }
15124       return p;
15125
15126     case Tag_ABI_PIC:
15127       val = read_uleb128 (p, &len, end);
15128       p += len;
15129       printf ("  Tag_ABI_PIC: ");
15130       switch (val)
15131         {
15132         case 0:
15133           printf (_("Code addressing position-dependent\n"));
15134           break;
15135         case 1:
15136           printf (_("Code addressing position-independent\n"));
15137           break;
15138         default:
15139           printf ("??? (%d)\n", val);
15140           break;
15141         }
15142       return p;
15143
15144     case Tag_ABI_array_object_alignment:
15145       val = read_uleb128 (p, &len, end);
15146       p += len;
15147       printf ("  Tag_ABI_array_object_alignment: ");
15148       switch (val)
15149         {
15150         case 0:
15151           printf (_("8-byte\n"));
15152           break;
15153         case 1:
15154           printf (_("4-byte\n"));
15155           break;
15156         case 2:
15157           printf (_("16-byte\n"));
15158           break;
15159         default:
15160           printf ("??? (%d)\n", val);
15161           break;
15162         }
15163       return p;
15164
15165     case Tag_ABI_array_object_align_expected:
15166       val = read_uleb128 (p, &len, end);
15167       p += len;
15168       printf ("  Tag_ABI_array_object_align_expected: ");
15169       switch (val)
15170         {
15171         case 0:
15172           printf (_("8-byte\n"));
15173           break;
15174         case 1:
15175           printf (_("4-byte\n"));
15176           break;
15177         case 2:
15178           printf (_("16-byte\n"));
15179           break;
15180         default:
15181           printf ("??? (%d)\n", val);
15182           break;
15183         }
15184       return p;
15185
15186     case Tag_ABI_compatibility:
15187       {
15188         val = read_uleb128 (p, &len, end);
15189         p += len;
15190         printf ("  Tag_ABI_compatibility: ");
15191         printf (_("flag = %d, vendor = "), val);
15192         if (p < end - 1)
15193           {
15194             size_t maxlen = (end - p) - 1;
15195
15196             print_symbol ((int) maxlen, (const char *) p);
15197             p += strnlen ((char *) p, maxlen) + 1;
15198           }
15199         else
15200           {
15201             printf (_("<corrupt>"));
15202             p = (unsigned char *) end;
15203           }
15204         putchar ('\n');
15205         return p;
15206       }
15207
15208     case Tag_ABI_conformance:
15209       {
15210         printf ("  Tag_ABI_conformance: \"");
15211         if (p < end - 1)
15212           {
15213             size_t maxlen = (end - p) - 1;
15214
15215             print_symbol ((int) maxlen, (const char *) p);
15216             p += strnlen ((char *) p, maxlen) + 1;
15217           }
15218         else
15219           {
15220             printf (_("<corrupt>"));
15221             p = (unsigned char *) end;
15222           }
15223         printf ("\"\n");
15224         return p;
15225       }
15226     }
15227
15228   return display_tag_value (tag, p, end);
15229 }
15230
15231 static void
15232 display_raw_attribute (unsigned char * p, unsigned char const * const end)
15233 {
15234   unsigned long addr = 0;
15235   size_t bytes = end - p;
15236
15237   assert (end >= p);
15238   while (bytes)
15239     {
15240       int j;
15241       int k;
15242       int lbytes = (bytes > 16 ? 16 : bytes);
15243
15244       printf ("  0x%8.8lx ", addr);
15245
15246       for (j = 0; j < 16; j++)
15247         {
15248           if (j < lbytes)
15249             printf ("%2.2x", p[j]);
15250           else
15251             printf ("  ");
15252
15253           if ((j & 3) == 3)
15254             printf (" ");
15255         }
15256
15257       for (j = 0; j < lbytes; j++)
15258         {
15259           k = p[j];
15260           if (k >= ' ' && k < 0x7f)
15261             printf ("%c", k);
15262           else
15263             printf (".");
15264         }
15265
15266       putchar ('\n');
15267
15268       p  += lbytes;
15269       bytes -= lbytes;
15270       addr += lbytes;
15271     }
15272
15273   putchar ('\n');
15274 }
15275
15276 static unsigned char *
15277 display_msp430x_attribute (unsigned char * p,
15278                            const unsigned char * const end)
15279 {
15280   unsigned int len;
15281   unsigned int val;
15282   unsigned int tag;
15283
15284   tag = read_uleb128 (p, & len, end);
15285   p += len;
15286
15287   switch (tag)
15288     {
15289     case OFBA_MSPABI_Tag_ISA:
15290       val = read_uleb128 (p, &len, end);
15291       p += len;
15292       printf ("  Tag_ISA: ");
15293       switch (val)
15294         {
15295         case 0: printf (_("None\n")); break;
15296         case 1: printf (_("MSP430\n")); break;
15297         case 2: printf (_("MSP430X\n")); break;
15298         default: printf ("??? (%d)\n", val); break;
15299         }
15300       break;
15301
15302     case OFBA_MSPABI_Tag_Code_Model:
15303       val = read_uleb128 (p, &len, end);
15304       p += len;
15305       printf ("  Tag_Code_Model: ");
15306       switch (val)
15307         {
15308         case 0: printf (_("None\n")); break;
15309         case 1: printf (_("Small\n")); break;
15310         case 2: printf (_("Large\n")); break;
15311         default: printf ("??? (%d)\n", val); break;
15312         }
15313       break;
15314
15315     case OFBA_MSPABI_Tag_Data_Model:
15316       val = read_uleb128 (p, &len, end);
15317       p += len;
15318       printf ("  Tag_Data_Model: ");
15319       switch (val)
15320         {
15321         case 0: printf (_("None\n")); break;
15322         case 1: printf (_("Small\n")); break;
15323         case 2: printf (_("Large\n")); break;
15324         case 3: printf (_("Restricted Large\n")); break;
15325         default: printf ("??? (%d)\n", val); break;
15326         }
15327       break;
15328
15329     default:
15330       printf (_("  <unknown tag %d>: "), tag);
15331
15332       if (tag & 1)
15333         {
15334           putchar ('"');
15335           if (p < end - 1)
15336             {
15337               size_t maxlen = (end - p) - 1;
15338
15339               print_symbol ((int) maxlen, (const char *) p);
15340               p += strnlen ((char *) p, maxlen) + 1;
15341             }
15342           else
15343             {
15344               printf (_("<corrupt>"));
15345               p = (unsigned char *) end;
15346             }
15347           printf ("\"\n");
15348         }
15349       else
15350         {
15351           val = read_uleb128 (p, &len, end);
15352           p += len;
15353           printf ("%d (0x%x)\n", val, val);
15354         }
15355       break;
15356    }
15357
15358   assert (p <= end);
15359   return p;
15360 }
15361
15362 static bfd_boolean
15363 process_attributes (Filedata * filedata,
15364                     const char * public_name,
15365                     unsigned int proc_type,
15366                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15367                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15368 {
15369   Elf_Internal_Shdr * sect;
15370   unsigned i;
15371   bfd_boolean res = TRUE;
15372
15373   /* Find the section header so that we get the size.  */
15374   for (i = 0, sect = filedata->section_headers;
15375        i < filedata->file_header.e_shnum;
15376        i++, sect++)
15377     {
15378       unsigned char * contents;
15379       unsigned char * p;
15380
15381       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15382         continue;
15383
15384       contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15385                                              sect->sh_size, _("attributes"));
15386       if (contents == NULL)
15387         {
15388           res = FALSE;
15389           continue;
15390         }
15391
15392       p = contents;
15393       /* The first character is the version of the attributes.
15394          Currently only version 1, (aka 'A') is recognised here.  */
15395       if (*p != 'A')
15396         {
15397           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15398           res = FALSE;
15399         }
15400       else
15401         {
15402           bfd_vma section_len;
15403
15404           section_len = sect->sh_size - 1;
15405           p++;
15406
15407           while (section_len > 0)
15408             {
15409               bfd_vma attr_len;
15410               unsigned int namelen;
15411               bfd_boolean public_section;
15412               bfd_boolean gnu_section;
15413
15414               if (section_len <= 4)
15415                 {
15416                   error (_("Tag section ends prematurely\n"));
15417                   res = FALSE;
15418                   break;
15419                 }
15420               attr_len = byte_get (p, 4);
15421               p += 4;
15422
15423               if (attr_len > section_len)
15424                 {
15425                   error (_("Bad attribute length (%u > %u)\n"),
15426                           (unsigned) attr_len, (unsigned) section_len);
15427                   attr_len = section_len;
15428                   res = FALSE;
15429                 }
15430               /* PR 17531: file: 001-101425-0.004  */
15431               else if (attr_len < 5)
15432                 {
15433                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
15434                   res = FALSE;
15435                   break;
15436                 }
15437
15438               section_len -= attr_len;
15439               attr_len -= 4;
15440
15441               namelen = strnlen ((char *) p, attr_len) + 1;
15442               if (namelen == 0 || namelen >= attr_len)
15443                 {
15444                   error (_("Corrupt attribute section name\n"));
15445                   res = FALSE;
15446                   break;
15447                 }
15448
15449               printf (_("Attribute Section: "));
15450               print_symbol (INT_MAX, (const char *) p);
15451               putchar ('\n');
15452
15453               if (public_name && streq ((char *) p, public_name))
15454                 public_section = TRUE;
15455               else
15456                 public_section = FALSE;
15457
15458               if (streq ((char *) p, "gnu"))
15459                 gnu_section = TRUE;
15460               else
15461                 gnu_section = FALSE;
15462
15463               p += namelen;
15464               attr_len -= namelen;
15465
15466               while (attr_len > 0 && p < contents + sect->sh_size)
15467                 {
15468                   int tag;
15469                   int val;
15470                   bfd_vma size;
15471                   unsigned char * end;
15472
15473                   /* PR binutils/17531: Safe handling of corrupt files.  */
15474                   if (attr_len < 6)
15475                     {
15476                       error (_("Unused bytes at end of section\n"));
15477                       res = FALSE;
15478                       section_len = 0;
15479                       break;
15480                     }
15481
15482                   tag = *(p++);
15483                   size = byte_get (p, 4);
15484                   if (size > attr_len)
15485                     {
15486                       error (_("Bad subsection length (%u > %u)\n"),
15487                               (unsigned) size, (unsigned) attr_len);
15488                       res = FALSE;
15489                       size = attr_len;
15490                     }
15491                   /* PR binutils/17531: Safe handling of corrupt files.  */
15492                   if (size < 6)
15493                     {
15494                       error (_("Bad subsection length (%u < 6)\n"),
15495                               (unsigned) size);
15496                       res = FALSE;
15497                       section_len = 0;
15498                       break;
15499                     }
15500
15501                   attr_len -= size;
15502                   end = p + size - 1;
15503                   assert (end <= contents + sect->sh_size);
15504                   p += 4;
15505
15506                   switch (tag)
15507                     {
15508                     case 1:
15509                       printf (_("File Attributes\n"));
15510                       break;
15511                     case 2:
15512                       printf (_("Section Attributes:"));
15513                       goto do_numlist;
15514                     case 3:
15515                       printf (_("Symbol Attributes:"));
15516                       /* Fall through.  */
15517                     do_numlist:
15518                       for (;;)
15519                         {
15520                           unsigned int j;
15521
15522                           val = read_uleb128 (p, &j, end);
15523                           p += j;
15524                           if (val == 0)
15525                             break;
15526                           printf (" %d", val);
15527                         }
15528                       printf ("\n");
15529                       break;
15530                     default:
15531                       printf (_("Unknown tag: %d\n"), tag);
15532                       public_section = FALSE;
15533                       break;
15534                     }
15535
15536                   if (public_section && display_pub_attribute != NULL)
15537                     {
15538                       while (p < end)
15539                         p = display_pub_attribute (p, end);
15540                       assert (p == end);
15541                     }
15542                   else if (gnu_section && display_proc_gnu_attribute != NULL)
15543                     {
15544                       while (p < end)
15545                         p = display_gnu_attribute (p,
15546                                                    display_proc_gnu_attribute,
15547                                                    end);
15548                       assert (p == end);
15549                     }
15550                   else if (p < end)
15551                     {
15552                       printf (_("  Unknown attribute:\n"));
15553                       display_raw_attribute (p, end);
15554                       p = end;
15555                     }
15556                   else
15557                     attr_len = 0;
15558                 }
15559             }
15560         }
15561
15562       free (contents);
15563     }
15564
15565   return res;
15566 }
15567
15568 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15569    Print the Address, Access and Initial fields of an entry at VMA ADDR
15570    and return the VMA of the next entry, or -1 if there was a problem.
15571    Does not read from DATA_END or beyond.  */
15572
15573 static bfd_vma
15574 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15575                       unsigned char * data_end)
15576 {
15577   printf ("  ");
15578   print_vma (addr, LONG_HEX);
15579   printf (" ");
15580   if (addr < pltgot + 0xfff0)
15581     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15582   else
15583     printf ("%10s", "");
15584   printf (" ");
15585   if (data == NULL)
15586     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15587   else
15588     {
15589       bfd_vma entry;
15590       unsigned char * from = data + addr - pltgot;
15591
15592       if (from + (is_32bit_elf ? 4 : 8) > data_end)
15593         {
15594           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15595           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15596           return (bfd_vma) -1;
15597         }
15598       else
15599         {
15600           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15601           print_vma (entry, LONG_HEX);
15602         }
15603     }
15604   return addr + (is_32bit_elf ? 4 : 8);
15605 }
15606
15607 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15608    PLTGOT.  Print the Address and Initial fields of an entry at VMA
15609    ADDR and return the VMA of the next entry.  */
15610
15611 static bfd_vma
15612 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15613 {
15614   printf ("  ");
15615   print_vma (addr, LONG_HEX);
15616   printf (" ");
15617   if (data == NULL)
15618     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15619   else
15620     {
15621       bfd_vma entry;
15622
15623       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15624       print_vma (entry, LONG_HEX);
15625     }
15626   return addr + (is_32bit_elf ? 4 : 8);
15627 }
15628
15629 static void
15630 print_mips_ases (unsigned int mask)
15631 {
15632   if (mask & AFL_ASE_DSP)
15633     fputs ("\n\tDSP ASE", stdout);
15634   if (mask & AFL_ASE_DSPR2)
15635     fputs ("\n\tDSP R2 ASE", stdout);
15636   if (mask & AFL_ASE_DSPR3)
15637     fputs ("\n\tDSP R3 ASE", stdout);
15638   if (mask & AFL_ASE_EVA)
15639     fputs ("\n\tEnhanced VA Scheme", stdout);
15640   if (mask & AFL_ASE_MCU)
15641     fputs ("\n\tMCU (MicroController) ASE", stdout);
15642   if (mask & AFL_ASE_MDMX)
15643     fputs ("\n\tMDMX ASE", stdout);
15644   if (mask & AFL_ASE_MIPS3D)
15645     fputs ("\n\tMIPS-3D ASE", stdout);
15646   if (mask & AFL_ASE_MT)
15647     fputs ("\n\tMT ASE", stdout);
15648   if (mask & AFL_ASE_SMARTMIPS)
15649     fputs ("\n\tSmartMIPS ASE", stdout);
15650   if (mask & AFL_ASE_VIRT)
15651     fputs ("\n\tVZ ASE", stdout);
15652   if (mask & AFL_ASE_MSA)
15653     fputs ("\n\tMSA ASE", stdout);
15654   if (mask & AFL_ASE_MIPS16)
15655     fputs ("\n\tMIPS16 ASE", stdout);
15656   if (mask & AFL_ASE_MICROMIPS)
15657     fputs ("\n\tMICROMIPS ASE", stdout);
15658   if (mask & AFL_ASE_XPA)
15659     fputs ("\n\tXPA ASE", stdout);
15660   if (mask & AFL_ASE_MIPS16E2)
15661     fputs ("\n\tMIPS16e2 ASE", stdout);
15662   if (mask & AFL_ASE_CRC)
15663     fputs ("\n\tCRC ASE", stdout);
15664   if (mask & AFL_ASE_GINV)
15665     fputs ("\n\tGINV ASE", stdout);
15666   if (mask & AFL_ASE_LOONGSON_MMI)
15667     fputs ("\n\tLoongson MMI ASE", stdout);
15668   if (mask & AFL_ASE_LOONGSON_CAM)
15669     fputs ("\n\tLoongson CAM ASE", stdout);
15670   if (mask & AFL_ASE_LOONGSON_EXT)
15671     fputs ("\n\tLoongson EXT ASE", stdout);
15672   if (mask & AFL_ASE_LOONGSON_EXT2)
15673     fputs ("\n\tLoongson EXT2 ASE", stdout);
15674   if (mask == 0)
15675     fprintf (stdout, "\n\t%s", _("None"));
15676   else if ((mask & ~AFL_ASE_MASK) != 0)
15677     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15678 }
15679
15680 static void
15681 print_mips_isa_ext (unsigned int isa_ext)
15682 {
15683   switch (isa_ext)
15684     {
15685     case 0:
15686       fputs (_("None"), stdout);
15687       break;
15688     case AFL_EXT_XLR:
15689       fputs ("RMI XLR", stdout);
15690       break;
15691     case AFL_EXT_OCTEON3:
15692       fputs ("Cavium Networks Octeon3", stdout);
15693       break;
15694     case AFL_EXT_OCTEON2:
15695       fputs ("Cavium Networks Octeon2", stdout);
15696       break;
15697     case AFL_EXT_OCTEONP:
15698       fputs ("Cavium Networks OcteonP", stdout);
15699       break;
15700     case AFL_EXT_OCTEON:
15701       fputs ("Cavium Networks Octeon", stdout);
15702       break;
15703     case AFL_EXT_5900:
15704       fputs ("Toshiba R5900", stdout);
15705       break;
15706     case AFL_EXT_4650:
15707       fputs ("MIPS R4650", stdout);
15708       break;
15709     case AFL_EXT_4010:
15710       fputs ("LSI R4010", stdout);
15711       break;
15712     case AFL_EXT_4100:
15713       fputs ("NEC VR4100", stdout);
15714       break;
15715     case AFL_EXT_3900:
15716       fputs ("Toshiba R3900", stdout);
15717       break;
15718     case AFL_EXT_10000:
15719       fputs ("MIPS R10000", stdout);
15720       break;
15721     case AFL_EXT_SB1:
15722       fputs ("Broadcom SB-1", stdout);
15723       break;
15724     case AFL_EXT_4111:
15725       fputs ("NEC VR4111/VR4181", stdout);
15726       break;
15727     case AFL_EXT_4120:
15728       fputs ("NEC VR4120", stdout);
15729       break;
15730     case AFL_EXT_5400:
15731       fputs ("NEC VR5400", stdout);
15732       break;
15733     case AFL_EXT_5500:
15734       fputs ("NEC VR5500", stdout);
15735       break;
15736     case AFL_EXT_LOONGSON_2E:
15737       fputs ("ST Microelectronics Loongson 2E", stdout);
15738       break;
15739     case AFL_EXT_LOONGSON_2F:
15740       fputs ("ST Microelectronics Loongson 2F", stdout);
15741       break;
15742     case AFL_EXT_INTERAPTIV_MR2:
15743       fputs ("Imagination interAptiv MR2", stdout);
15744       break;
15745     default:
15746       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15747     }
15748 }
15749
15750 static signed int
15751 get_mips_reg_size (int reg_size)
15752 {
15753   return (reg_size == AFL_REG_NONE) ? 0
15754          : (reg_size == AFL_REG_32) ? 32
15755          : (reg_size == AFL_REG_64) ? 64
15756          : (reg_size == AFL_REG_128) ? 128
15757          : -1;
15758 }
15759
15760 static bfd_boolean
15761 process_mips_specific (Filedata * filedata)
15762 {
15763   Elf_Internal_Dyn * entry;
15764   Elf_Internal_Shdr *sect = NULL;
15765   size_t liblist_offset = 0;
15766   size_t liblistno = 0;
15767   size_t conflictsno = 0;
15768   size_t options_offset = 0;
15769   size_t conflicts_offset = 0;
15770   size_t pltrelsz = 0;
15771   size_t pltrel = 0;
15772   bfd_vma pltgot = 0;
15773   bfd_vma mips_pltgot = 0;
15774   bfd_vma jmprel = 0;
15775   bfd_vma local_gotno = 0;
15776   bfd_vma gotsym = 0;
15777   bfd_vma symtabno = 0;
15778   bfd_boolean res = TRUE;
15779
15780   if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
15781                             display_mips_gnu_attribute))
15782     res = FALSE;
15783
15784   sect = find_section (filedata, ".MIPS.abiflags");
15785
15786   if (sect != NULL)
15787     {
15788       Elf_External_ABIFlags_v0 *abiflags_ext;
15789       Elf_Internal_ABIFlags_v0 abiflags_in;
15790
15791       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15792         {
15793           error (_("Corrupt MIPS ABI Flags section.\n"));
15794           res = FALSE;
15795         }
15796       else
15797         {
15798           abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
15799                                    sect->sh_size, _("MIPS ABI Flags section"));
15800           if (abiflags_ext)
15801             {
15802               abiflags_in.version = BYTE_GET (abiflags_ext->version);
15803               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15804               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15805               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15806               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15807               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15808               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15809               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15810               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15811               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15812               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15813
15814               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15815               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15816               if (abiflags_in.isa_rev > 1)
15817                 printf ("r%d", abiflags_in.isa_rev);
15818               printf ("\nGPR size: %d",
15819                       get_mips_reg_size (abiflags_in.gpr_size));
15820               printf ("\nCPR1 size: %d",
15821                       get_mips_reg_size (abiflags_in.cpr1_size));
15822               printf ("\nCPR2 size: %d",
15823                       get_mips_reg_size (abiflags_in.cpr2_size));
15824               fputs ("\nFP ABI: ", stdout);
15825               print_mips_fp_abi_value (abiflags_in.fp_abi);
15826               fputs ("ISA Extension: ", stdout);
15827               print_mips_isa_ext (abiflags_in.isa_ext);
15828               fputs ("\nASEs:", stdout);
15829               print_mips_ases (abiflags_in.ases);
15830               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15831               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15832               fputc ('\n', stdout);
15833               free (abiflags_ext);
15834             }
15835         }
15836     }
15837
15838   /* We have a lot of special sections.  Thanks SGI!  */
15839   if (dynamic_section == NULL)
15840     {
15841       /* No dynamic information available.  See if there is static GOT.  */
15842       sect = find_section (filedata, ".got");
15843       if (sect != NULL)
15844         {
15845           unsigned char *data_end;
15846           unsigned char *data;
15847           bfd_vma ent, end;
15848           int addr_size;
15849
15850           pltgot = sect->sh_addr;
15851
15852           ent = pltgot;
15853           addr_size = (is_32bit_elf ? 4 : 8);
15854           end = pltgot + sect->sh_size;
15855
15856           data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
15857                                              end - pltgot, 1,
15858                                              _("Global Offset Table data"));
15859           /* PR 12855: Null data is handled gracefully throughout.  */
15860           data_end = data + (end - pltgot);
15861
15862           printf (_("\nStatic GOT:\n"));
15863           printf (_(" Canonical gp value: "));
15864           print_vma (ent + 0x7ff0, LONG_HEX);
15865           printf ("\n\n");
15866
15867           /* In a dynamic binary GOT[0] is reserved for the dynamic
15868              loader to store the lazy resolver pointer, however in
15869              a static binary it may well have been omitted and GOT
15870              reduced to a table of addresses.
15871              PR 21344: Check for the entry being fully available
15872              before fetching it.  */
15873           if (data
15874               && data + ent - pltgot + addr_size <= data_end
15875               && byte_get (data + ent - pltgot, addr_size) == 0)
15876             {
15877               printf (_(" Reserved entries:\n"));
15878               printf (_("  %*s %10s %*s\n"),
15879                       addr_size * 2, _("Address"), _("Access"),
15880                       addr_size * 2, _("Value"));
15881               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15882               printf ("\n");
15883               if (ent == (bfd_vma) -1)
15884                 goto sgot_print_fail;
15885
15886               /* Check for the MSB of GOT[1] being set, identifying a
15887                  GNU object.  This entry will be used by some runtime
15888                  loaders, to store the module pointer.  Otherwise this
15889                  is an ordinary local entry.
15890                  PR 21344: Check for the entry being fully available
15891                  before fetching it.  */
15892               if (data
15893                   && data + ent - pltgot + addr_size <= data_end
15894                   && (byte_get (data + ent - pltgot, addr_size)
15895                       >> (addr_size * 8 - 1)) != 0)
15896                 {
15897                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15898                   printf ("\n");
15899                   if (ent == (bfd_vma) -1)
15900                     goto sgot_print_fail;
15901                 }
15902               printf ("\n");
15903             }
15904
15905           if (data != NULL && ent < end)
15906             {
15907               printf (_(" Local entries:\n"));
15908               printf ("  %*s %10s %*s\n",
15909                       addr_size * 2, _("Address"), _("Access"),
15910                       addr_size * 2, _("Value"));
15911               while (ent < end)
15912                 {
15913                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15914                   printf ("\n");
15915                   if (ent == (bfd_vma) -1)
15916                     goto sgot_print_fail;
15917                 }
15918               printf ("\n");
15919             }
15920
15921         sgot_print_fail:
15922           if (data)
15923             free (data);
15924         }
15925       return res;
15926     }
15927
15928   for (entry = dynamic_section;
15929        /* PR 17531 file: 012-50589-0.004.  */
15930        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15931        ++entry)
15932     switch (entry->d_tag)
15933       {
15934       case DT_MIPS_LIBLIST:
15935         liblist_offset
15936           = offset_from_vma (filedata, entry->d_un.d_val,
15937                              liblistno * sizeof (Elf32_External_Lib));
15938         break;
15939       case DT_MIPS_LIBLISTNO:
15940         liblistno = entry->d_un.d_val;
15941         break;
15942       case DT_MIPS_OPTIONS:
15943         options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
15944         break;
15945       case DT_MIPS_CONFLICT:
15946         conflicts_offset
15947           = offset_from_vma (filedata, entry->d_un.d_val,
15948                              conflictsno * sizeof (Elf32_External_Conflict));
15949         break;
15950       case DT_MIPS_CONFLICTNO:
15951         conflictsno = entry->d_un.d_val;
15952         break;
15953       case DT_PLTGOT:
15954         pltgot = entry->d_un.d_ptr;
15955         break;
15956       case DT_MIPS_LOCAL_GOTNO:
15957         local_gotno = entry->d_un.d_val;
15958         break;
15959       case DT_MIPS_GOTSYM:
15960         gotsym = entry->d_un.d_val;
15961         break;
15962       case DT_MIPS_SYMTABNO:
15963         symtabno = entry->d_un.d_val;
15964         break;
15965       case DT_MIPS_PLTGOT:
15966         mips_pltgot = entry->d_un.d_ptr;
15967         break;
15968       case DT_PLTREL:
15969         pltrel = entry->d_un.d_val;
15970         break;
15971       case DT_PLTRELSZ:
15972         pltrelsz = entry->d_un.d_val;
15973         break;
15974       case DT_JMPREL:
15975         jmprel = entry->d_un.d_ptr;
15976         break;
15977       default:
15978         break;
15979       }
15980
15981   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15982     {
15983       Elf32_External_Lib * elib;
15984       size_t cnt;
15985
15986       elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
15987                                               liblistno,
15988                                               sizeof (Elf32_External_Lib),
15989                                               _("liblist section data"));
15990       if (elib)
15991         {
15992           printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15993                             "\nSection '.liblist' contains %lu entries:\n",
15994                             (unsigned long) liblistno),
15995                   (unsigned long) liblistno);
15996           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
15997                  stdout);
15998
15999           for (cnt = 0; cnt < liblistno; ++cnt)
16000             {
16001               Elf32_Lib liblist;
16002               time_t atime;
16003               char timebuf[128];
16004               struct tm * tmp;
16005
16006               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16007               atime = BYTE_GET (elib[cnt].l_time_stamp);
16008               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16009               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16010               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16011
16012               tmp = gmtime (&atime);
16013               snprintf (timebuf, sizeof (timebuf),
16014                         "%04u-%02u-%02uT%02u:%02u:%02u",
16015                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16016                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16017
16018               printf ("%3lu: ", (unsigned long) cnt);
16019               if (VALID_DYNAMIC_NAME (liblist.l_name))
16020                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
16021               else
16022                 printf (_("<corrupt: %9ld>"), liblist.l_name);
16023               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
16024                       liblist.l_version);
16025
16026               if (liblist.l_flags == 0)
16027                 puts (_(" NONE"));
16028               else
16029                 {
16030                   static const struct
16031                   {
16032                     const char * name;
16033                     int bit;
16034                   }
16035                   l_flags_vals[] =
16036                   {
16037                     { " EXACT_MATCH", LL_EXACT_MATCH },
16038                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
16039                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
16040                     { " EXPORTS", LL_EXPORTS },
16041                     { " DELAY_LOAD", LL_DELAY_LOAD },
16042                     { " DELTA", LL_DELTA }
16043                   };
16044                   int flags = liblist.l_flags;
16045                   size_t fcnt;
16046
16047                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
16048                     if ((flags & l_flags_vals[fcnt].bit) != 0)
16049                       {
16050                         fputs (l_flags_vals[fcnt].name, stdout);
16051                         flags ^= l_flags_vals[fcnt].bit;
16052                       }
16053                   if (flags != 0)
16054                     printf (" %#x", (unsigned int) flags);
16055
16056                   puts ("");
16057                 }
16058             }
16059
16060           free (elib);
16061         }
16062       else
16063         res = FALSE;
16064     }
16065
16066   if (options_offset != 0)
16067     {
16068       Elf_External_Options * eopt;
16069       Elf_Internal_Options * iopt;
16070       Elf_Internal_Options * option;
16071       size_t offset;
16072       int cnt;
16073       sect = filedata->section_headers;
16074
16075       /* Find the section header so that we get the size.  */
16076       sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
16077       /* PR 17533 file: 012-277276-0.004.  */
16078       if (sect == NULL)
16079         {
16080           error (_("No MIPS_OPTIONS header found\n"));
16081           return FALSE;
16082         }
16083
16084       eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
16085                                                 sect->sh_size, _("options"));
16086       if (eopt)
16087         {
16088           iopt = (Elf_Internal_Options *)
16089               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
16090           if (iopt == NULL)
16091             {
16092               error (_("Out of memory allocating space for MIPS options\n"));
16093               return FALSE;
16094             }
16095
16096           offset = cnt = 0;
16097           option = iopt;
16098
16099           while (offset <= sect->sh_size - sizeof (* eopt))
16100             {
16101               Elf_External_Options * eoption;
16102
16103               eoption = (Elf_External_Options *) ((char *) eopt + offset);
16104
16105               option->kind = BYTE_GET (eoption->kind);
16106               option->size = BYTE_GET (eoption->size);
16107               option->section = BYTE_GET (eoption->section);
16108               option->info = BYTE_GET (eoption->info);
16109
16110               /* PR 17531: file: ffa0fa3b.  */
16111               if (option->size < sizeof (* eopt)
16112                   || offset + option->size > sect->sh_size)
16113                 {
16114                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
16115                   return FALSE;
16116                 }
16117               offset += option->size;
16118
16119               ++option;
16120               ++cnt;
16121             }
16122
16123           printf (ngettext ("\nSection '%s' contains %d entry:\n",
16124                             "\nSection '%s' contains %d entries:\n",
16125                             cnt),
16126                   printable_section_name (filedata, sect), cnt);
16127
16128           option = iopt;
16129           offset = 0;
16130
16131           while (cnt-- > 0)
16132             {
16133               size_t len;
16134
16135               switch (option->kind)
16136                 {
16137                 case ODK_NULL:
16138                   /* This shouldn't happen.  */
16139                   printf (" NULL       %d %lx", option->section, option->info);
16140                   break;
16141                 case ODK_REGINFO:
16142                   printf (" REGINFO    ");
16143                   if (filedata->file_header.e_machine == EM_MIPS)
16144                     {
16145                       /* 32bit form.  */
16146                       Elf32_External_RegInfo * ereg;
16147                       Elf32_RegInfo reginfo;
16148
16149                       ereg = (Elf32_External_RegInfo *) (option + 1);
16150                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16151                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16152                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16153                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16154                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16155                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16156
16157                       printf ("GPR %08lx  GP 0x%lx\n",
16158                               reginfo.ri_gprmask,
16159                               (unsigned long) reginfo.ri_gp_value);
16160                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
16161                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16162                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16163                     }
16164                   else
16165                     {
16166                       /* 64 bit form.  */
16167                       Elf64_External_RegInfo * ereg;
16168                       Elf64_Internal_RegInfo reginfo;
16169
16170                       ereg = (Elf64_External_RegInfo *) (option + 1);
16171                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
16172                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16173                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16174                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16175                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16176                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
16177
16178                       printf ("GPR %08lx  GP 0x",
16179                               reginfo.ri_gprmask);
16180                       printf_vma (reginfo.ri_gp_value);
16181                       printf ("\n");
16182
16183                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
16184                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16185                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16186                     }
16187                   ++option;
16188                   continue;
16189                 case ODK_EXCEPTIONS:
16190                   fputs (" EXCEPTIONS fpe_min(", stdout);
16191                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
16192                   fputs (") fpe_max(", stdout);
16193                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
16194                   fputs (")", stdout);
16195
16196                   if (option->info & OEX_PAGE0)
16197                     fputs (" PAGE0", stdout);
16198                   if (option->info & OEX_SMM)
16199                     fputs (" SMM", stdout);
16200                   if (option->info & OEX_FPDBUG)
16201                     fputs (" FPDBUG", stdout);
16202                   if (option->info & OEX_DISMISS)
16203                     fputs (" DISMISS", stdout);
16204                   break;
16205                 case ODK_PAD:
16206                   fputs (" PAD       ", stdout);
16207                   if (option->info & OPAD_PREFIX)
16208                     fputs (" PREFIX", stdout);
16209                   if (option->info & OPAD_POSTFIX)
16210                     fputs (" POSTFIX", stdout);
16211                   if (option->info & OPAD_SYMBOL)
16212                     fputs (" SYMBOL", stdout);
16213                   break;
16214                 case ODK_HWPATCH:
16215                   fputs (" HWPATCH   ", stdout);
16216                   if (option->info & OHW_R4KEOP)
16217                     fputs (" R4KEOP", stdout);
16218                   if (option->info & OHW_R8KPFETCH)
16219                     fputs (" R8KPFETCH", stdout);
16220                   if (option->info & OHW_R5KEOP)
16221                     fputs (" R5KEOP", stdout);
16222                   if (option->info & OHW_R5KCVTL)
16223                     fputs (" R5KCVTL", stdout);
16224                   break;
16225                 case ODK_FILL:
16226                   fputs (" FILL       ", stdout);
16227                   /* XXX Print content of info word?  */
16228                   break;
16229                 case ODK_TAGS:
16230                   fputs (" TAGS       ", stdout);
16231                   /* XXX Print content of info word?  */
16232                   break;
16233                 case ODK_HWAND:
16234                   fputs (" HWAND     ", stdout);
16235                   if (option->info & OHWA0_R4KEOP_CHECKED)
16236                     fputs (" R4KEOP_CHECKED", stdout);
16237                   if (option->info & OHWA0_R4KEOP_CLEAN)
16238                     fputs (" R4KEOP_CLEAN", stdout);
16239                   break;
16240                 case ODK_HWOR:
16241                   fputs (" HWOR      ", stdout);
16242                   if (option->info & OHWA0_R4KEOP_CHECKED)
16243                     fputs (" R4KEOP_CHECKED", stdout);
16244                   if (option->info & OHWA0_R4KEOP_CLEAN)
16245                     fputs (" R4KEOP_CLEAN", stdout);
16246                   break;
16247                 case ODK_GP_GROUP:
16248                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
16249                           option->info & OGP_GROUP,
16250                           (option->info & OGP_SELF) >> 16);
16251                   break;
16252                 case ODK_IDENT:
16253                   printf (" IDENT     %#06lx  self-contained %#06lx",
16254                           option->info & OGP_GROUP,
16255                           (option->info & OGP_SELF) >> 16);
16256                   break;
16257                 default:
16258                   /* This shouldn't happen.  */
16259                   printf (" %3d ???     %d %lx",
16260                           option->kind, option->section, option->info);
16261                   break;
16262                 }
16263
16264               len = sizeof (* eopt);
16265               while (len < option->size)
16266                 {
16267                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
16268
16269                   if (ISPRINT (datum))
16270                     printf ("%c", datum);
16271                   else
16272                     printf ("\\%03o", datum);
16273                   len ++;
16274                 }
16275               fputs ("\n", stdout);
16276
16277               offset += option->size;
16278               ++option;
16279             }
16280
16281           free (eopt);
16282         }
16283       else
16284         res = FALSE;
16285     }
16286
16287   if (conflicts_offset != 0 && conflictsno != 0)
16288     {
16289       Elf32_Conflict * iconf;
16290       size_t cnt;
16291
16292       if (dynamic_symbols == NULL)
16293         {
16294           error (_("conflict list found without a dynamic symbol table\n"));
16295           return FALSE;
16296         }
16297
16298       /* PR 21345 - print a slightly more helpful error message
16299          if we are sure that the cmalloc will fail.  */
16300       if (conflictsno * sizeof (* iconf) > filedata->file_size)
16301         {
16302           error (_("Overlarge number of conflicts detected: %lx\n"),
16303                  (long) conflictsno);
16304           return FALSE;
16305         }
16306
16307       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16308       if (iconf == NULL)
16309         {
16310           error (_("Out of memory allocating space for dynamic conflicts\n"));
16311           return FALSE;
16312         }
16313
16314       if (is_32bit_elf)
16315         {
16316           Elf32_External_Conflict * econf32;
16317
16318           econf32 = (Elf32_External_Conflict *)
16319               get_data (NULL, filedata, conflicts_offset, conflictsno,
16320                         sizeof (* econf32), _("conflict"));
16321           if (!econf32)
16322             return FALSE;
16323
16324           for (cnt = 0; cnt < conflictsno; ++cnt)
16325             iconf[cnt] = BYTE_GET (econf32[cnt]);
16326
16327           free (econf32);
16328         }
16329       else
16330         {
16331           Elf64_External_Conflict * econf64;
16332
16333           econf64 = (Elf64_External_Conflict *)
16334               get_data (NULL, filedata, conflicts_offset, conflictsno,
16335                         sizeof (* econf64), _("conflict"));
16336           if (!econf64)
16337             return FALSE;
16338
16339           for (cnt = 0; cnt < conflictsno; ++cnt)
16340             iconf[cnt] = BYTE_GET (econf64[cnt]);
16341
16342           free (econf64);
16343         }
16344
16345       printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16346                         "\nSection '.conflict' contains %lu entries:\n",
16347                         (unsigned long) conflictsno),
16348               (unsigned long) conflictsno);
16349       puts (_("  Num:    Index       Value  Name"));
16350
16351       for (cnt = 0; cnt < conflictsno; ++cnt)
16352         {
16353           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
16354
16355           if (iconf[cnt] >= num_dynamic_syms)
16356             printf (_("<corrupt symbol index>"));
16357           else
16358             {
16359               Elf_Internal_Sym * psym;
16360
16361               psym = & dynamic_symbols[iconf[cnt]];
16362               print_vma (psym->st_value, FULL_HEX);
16363               putchar (' ');
16364               if (VALID_DYNAMIC_NAME (psym->st_name))
16365                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16366               else
16367                 printf (_("<corrupt: %14ld>"), psym->st_name);
16368             }
16369           putchar ('\n');
16370         }
16371
16372       free (iconf);
16373     }
16374
16375   if (pltgot != 0 && local_gotno != 0)
16376     {
16377       bfd_vma ent, local_end, global_end;
16378       size_t i, offset;
16379       unsigned char * data;
16380       unsigned char * data_end;
16381       int addr_size;
16382
16383       ent = pltgot;
16384       addr_size = (is_32bit_elf ? 4 : 8);
16385       local_end = pltgot + local_gotno * addr_size;
16386
16387       /* PR binutils/17533 file: 012-111227-0.004  */
16388       if (symtabno < gotsym)
16389         {
16390           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16391                  (unsigned long) gotsym, (unsigned long) symtabno);
16392           return FALSE;
16393         }
16394
16395       global_end = local_end + (symtabno - gotsym) * addr_size;
16396       /* PR 17531: file: 54c91a34.  */
16397       if (global_end < local_end)
16398         {
16399           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
16400           return FALSE;
16401         }
16402
16403       offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
16404       data = (unsigned char *) get_data (NULL, filedata, offset,
16405                                          global_end - pltgot, 1,
16406                                          _("Global Offset Table data"));
16407       /* PR 12855: Null data is handled gracefully throughout.  */
16408       data_end = data + (global_end - pltgot);
16409
16410       printf (_("\nPrimary GOT:\n"));
16411       printf (_(" Canonical gp value: "));
16412       print_vma (pltgot + 0x7ff0, LONG_HEX);
16413       printf ("\n\n");
16414
16415       printf (_(" Reserved entries:\n"));
16416       printf (_("  %*s %10s %*s Purpose\n"),
16417               addr_size * 2, _("Address"), _("Access"),
16418               addr_size * 2, _("Initial"));
16419       ent = print_mips_got_entry (data, pltgot, ent, data_end);
16420       printf (_(" Lazy resolver\n"));
16421       if (ent == (bfd_vma) -1)
16422         goto got_print_fail;
16423
16424       /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16425          This entry will be used by some runtime loaders, to store the
16426          module pointer.  Otherwise this is an ordinary local entry.
16427          PR 21344: Check for the entry being fully available before
16428          fetching it.  */
16429       if (data
16430           && data + ent - pltgot + addr_size <= data_end
16431           && (byte_get (data + ent - pltgot, addr_size)
16432               >> (addr_size * 8 - 1)) != 0)
16433         {
16434           ent = print_mips_got_entry (data, pltgot, ent, data_end);
16435           printf (_(" Module pointer (GNU extension)\n"));
16436           if (ent == (bfd_vma) -1)
16437             goto got_print_fail;
16438         }
16439       printf ("\n");
16440
16441       if (data != NULL && ent < local_end)
16442         {
16443           printf (_(" Local entries:\n"));
16444           printf ("  %*s %10s %*s\n",
16445                   addr_size * 2, _("Address"), _("Access"),
16446                   addr_size * 2, _("Initial"));
16447           while (ent < local_end)
16448             {
16449               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16450               printf ("\n");
16451               if (ent == (bfd_vma) -1)
16452                 goto got_print_fail;
16453             }
16454           printf ("\n");
16455         }
16456
16457       if (data != NULL && gotsym < symtabno)
16458         {
16459           int sym_width;
16460
16461           printf (_(" Global entries:\n"));
16462           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
16463                   addr_size * 2, _("Address"),
16464                   _("Access"),
16465                   addr_size * 2, _("Initial"),
16466                   addr_size * 2, _("Sym.Val."),
16467                   _("Type"),
16468                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
16469                   _("Ndx"), _("Name"));
16470
16471           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
16472
16473           for (i = gotsym; i < symtabno; i++)
16474             {
16475               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16476               printf (" ");
16477
16478               if (dynamic_symbols == NULL)
16479                 printf (_("<no dynamic symbols>"));
16480               else if (i < num_dynamic_syms)
16481                 {
16482                   Elf_Internal_Sym * psym = dynamic_symbols + i;
16483
16484                   print_vma (psym->st_value, LONG_HEX);
16485                   printf (" %-7s %3s ",
16486                           get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16487                           get_symbol_index_type (filedata, psym->st_shndx));
16488
16489                   if (VALID_DYNAMIC_NAME (psym->st_name))
16490                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16491                   else
16492                     printf (_("<corrupt: %14ld>"), psym->st_name);
16493                 }
16494               else
16495                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16496                         (unsigned long) i);
16497
16498               printf ("\n");
16499               if (ent == (bfd_vma) -1)
16500                 break;
16501             }
16502           printf ("\n");
16503         }
16504
16505     got_print_fail:
16506       if (data)
16507         free (data);
16508     }
16509
16510   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
16511     {
16512       bfd_vma ent, end;
16513       size_t offset, rel_offset;
16514       unsigned long count, i;
16515       unsigned char * data;
16516       int addr_size, sym_width;
16517       Elf_Internal_Rela * rels;
16518
16519       rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
16520       if (pltrel == DT_RELA)
16521         {
16522           if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16523             return FALSE;
16524         }
16525       else
16526         {
16527           if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16528             return FALSE;
16529         }
16530
16531       ent = mips_pltgot;
16532       addr_size = (is_32bit_elf ? 4 : 8);
16533       end = mips_pltgot + (2 + count) * addr_size;
16534
16535       offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
16536       data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
16537                                          1, _("Procedure Linkage Table data"));
16538       if (data == NULL)
16539         return FALSE;
16540
16541       printf ("\nPLT GOT:\n\n");
16542       printf (_(" Reserved entries:\n"));
16543       printf (_("  %*s %*s Purpose\n"),
16544               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
16545       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16546       printf (_(" PLT lazy resolver\n"));
16547       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16548       printf (_(" Module pointer\n"));
16549       printf ("\n");
16550
16551       printf (_(" Entries:\n"));
16552       printf ("  %*s %*s %*s %-7s %3s %s\n",
16553               addr_size * 2, _("Address"),
16554               addr_size * 2, _("Initial"),
16555               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16556       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
16557       for (i = 0; i < count; i++)
16558         {
16559           unsigned long idx = get_reloc_symindex (rels[i].r_info);
16560
16561           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16562           printf (" ");
16563
16564           if (idx >= num_dynamic_syms)
16565             printf (_("<corrupt symbol index: %lu>"), idx);
16566           else
16567             {
16568               Elf_Internal_Sym * psym = dynamic_symbols + idx;
16569
16570               print_vma (psym->st_value, LONG_HEX);
16571               printf (" %-7s %3s ",
16572                       get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16573                       get_symbol_index_type (filedata, psym->st_shndx));
16574               if (VALID_DYNAMIC_NAME (psym->st_name))
16575                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16576               else
16577                 printf (_("<corrupt: %14ld>"), psym->st_name);
16578             }
16579           printf ("\n");
16580         }
16581       printf ("\n");
16582
16583       if (data)
16584         free (data);
16585       free (rels);
16586     }
16587
16588   return res;
16589 }
16590
16591 static bfd_boolean
16592 process_nds32_specific (Filedata * filedata)
16593 {
16594   Elf_Internal_Shdr *sect = NULL;
16595
16596   sect = find_section (filedata, ".nds32_e_flags");
16597   if (sect != NULL)
16598     {
16599       unsigned int *flag;
16600
16601       printf ("\nNDS32 elf flags section:\n");
16602       flag = get_data (NULL, filedata, sect->sh_offset, 1,
16603                        sect->sh_size, _("NDS32 elf flags section"));
16604
16605       if (! flag)
16606         return FALSE;
16607
16608       switch ((*flag) & 0x3)
16609         {
16610         case 0:
16611           printf ("(VEC_SIZE):\tNo entry.\n");
16612           break;
16613         case 1:
16614           printf ("(VEC_SIZE):\t4 bytes\n");
16615           break;
16616         case 2:
16617           printf ("(VEC_SIZE):\t16 bytes\n");
16618           break;
16619         case 3:
16620           printf ("(VEC_SIZE):\treserved\n");
16621           break;
16622         }
16623     }
16624
16625   return TRUE;
16626 }
16627
16628 static bfd_boolean
16629 process_gnu_liblist (Filedata * filedata)
16630 {
16631   Elf_Internal_Shdr * section;
16632   Elf_Internal_Shdr * string_sec;
16633   Elf32_External_Lib * elib;
16634   char * strtab;
16635   size_t strtab_size;
16636   size_t cnt;
16637   unsigned long num_liblist;
16638   unsigned i;
16639   bfd_boolean res = TRUE;
16640
16641   if (! do_arch)
16642     return TRUE;
16643
16644   for (i = 0, section = filedata->section_headers;
16645        i < filedata->file_header.e_shnum;
16646        i++, section++)
16647     {
16648       switch (section->sh_type)
16649         {
16650         case SHT_GNU_LIBLIST:
16651           if (section->sh_link >= filedata->file_header.e_shnum)
16652             break;
16653
16654           elib = (Elf32_External_Lib *)
16655               get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
16656                         _("liblist section data"));
16657
16658           if (elib == NULL)
16659             {
16660               res = FALSE;
16661               break;
16662             }
16663
16664           string_sec = filedata->section_headers + section->sh_link;
16665           strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
16666                                       string_sec->sh_size,
16667                                       _("liblist string table"));
16668           if (strtab == NULL
16669               || section->sh_entsize != sizeof (Elf32_External_Lib))
16670             {
16671               free (elib);
16672               free (strtab);
16673               res = FALSE;
16674               break;
16675             }
16676           strtab_size = string_sec->sh_size;
16677
16678           num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
16679           printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16680                             "\nLibrary list section '%s' contains %lu entries:\n",
16681                             num_liblist),
16682                   printable_section_name (filedata, section),
16683                   num_liblist);
16684
16685           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
16686
16687           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16688                ++cnt)
16689             {
16690               Elf32_Lib liblist;
16691               time_t atime;
16692               char timebuf[128];
16693               struct tm * tmp;
16694
16695               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16696               atime = BYTE_GET (elib[cnt].l_time_stamp);
16697               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16698               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16699               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16700
16701               tmp = gmtime (&atime);
16702               snprintf (timebuf, sizeof (timebuf),
16703                         "%04u-%02u-%02uT%02u:%02u:%02u",
16704                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16705                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16706
16707               printf ("%3lu: ", (unsigned long) cnt);
16708               if (do_wide)
16709                 printf ("%-20s", liblist.l_name < strtab_size
16710                         ? strtab + liblist.l_name : _("<corrupt>"));
16711               else
16712                 printf ("%-20.20s", liblist.l_name < strtab_size
16713                         ? strtab + liblist.l_name : _("<corrupt>"));
16714               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16715                       liblist.l_version, liblist.l_flags);
16716             }
16717
16718           free (elib);
16719           free (strtab);
16720         }
16721     }
16722
16723   return res;
16724 }
16725
16726 static const char *
16727 get_note_type (Filedata * filedata, unsigned e_type)
16728 {
16729   static char buff[64];
16730
16731   if (filedata->file_header.e_type == ET_CORE)
16732     switch (e_type)
16733       {
16734       case NT_AUXV:
16735         return _("NT_AUXV (auxiliary vector)");
16736       case NT_PRSTATUS:
16737         return _("NT_PRSTATUS (prstatus structure)");
16738       case NT_FPREGSET:
16739         return _("NT_FPREGSET (floating point registers)");
16740       case NT_PRPSINFO:
16741         return _("NT_PRPSINFO (prpsinfo structure)");
16742       case NT_TASKSTRUCT:
16743         return _("NT_TASKSTRUCT (task structure)");
16744       case NT_PRXFPREG:
16745         return _("NT_PRXFPREG (user_xfpregs structure)");
16746       case NT_PPC_VMX:
16747         return _("NT_PPC_VMX (ppc Altivec registers)");
16748       case NT_PPC_VSX:
16749         return _("NT_PPC_VSX (ppc VSX registers)");
16750       case NT_PPC_TAR:
16751         return _("NT_PPC_TAR (ppc TAR register)");
16752       case NT_PPC_PPR:
16753         return _("NT_PPC_PPR (ppc PPR register)");
16754       case NT_PPC_DSCR:
16755         return _("NT_PPC_DSCR (ppc DSCR register)");
16756       case NT_PPC_EBB:
16757         return _("NT_PPC_EBB (ppc EBB registers)");
16758       case NT_PPC_PMU:
16759         return _("NT_PPC_PMU (ppc PMU registers)");
16760       case NT_PPC_TM_CGPR:
16761         return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16762       case NT_PPC_TM_CFPR:
16763         return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16764       case NT_PPC_TM_CVMX:
16765         return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16766       case NT_PPC_TM_CVSX:
16767         return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
16768       case NT_PPC_TM_SPR:
16769         return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16770       case NT_PPC_TM_CTAR:
16771         return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16772       case NT_PPC_TM_CPPR:
16773         return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16774       case NT_PPC_TM_CDSCR:
16775         return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16776       case NT_386_TLS:
16777         return _("NT_386_TLS (x86 TLS information)");
16778       case NT_386_IOPERM:
16779         return _("NT_386_IOPERM (x86 I/O permissions)");
16780       case NT_X86_XSTATE:
16781         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16782       case NT_S390_HIGH_GPRS:
16783         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16784       case NT_S390_TIMER:
16785         return _("NT_S390_TIMER (s390 timer register)");
16786       case NT_S390_TODCMP:
16787         return _("NT_S390_TODCMP (s390 TOD comparator register)");
16788       case NT_S390_TODPREG:
16789         return _("NT_S390_TODPREG (s390 TOD programmable register)");
16790       case NT_S390_CTRS:
16791         return _("NT_S390_CTRS (s390 control registers)");
16792       case NT_S390_PREFIX:
16793         return _("NT_S390_PREFIX (s390 prefix register)");
16794       case NT_S390_LAST_BREAK:
16795         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16796       case NT_S390_SYSTEM_CALL:
16797         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16798       case NT_S390_TDB:
16799         return _("NT_S390_TDB (s390 transaction diagnostic block)");
16800       case NT_S390_VXRS_LOW:
16801         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16802       case NT_S390_VXRS_HIGH:
16803         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16804       case NT_S390_GS_CB:
16805         return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16806       case NT_S390_GS_BC:
16807         return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16808       case NT_ARM_VFP:
16809         return _("NT_ARM_VFP (arm VFP registers)");
16810       case NT_ARM_TLS:
16811         return _("NT_ARM_TLS (AArch TLS registers)");
16812       case NT_ARM_HW_BREAK:
16813         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16814       case NT_ARM_HW_WATCH:
16815         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16816       case NT_PSTATUS:
16817         return _("NT_PSTATUS (pstatus structure)");
16818       case NT_FPREGS:
16819         return _("NT_FPREGS (floating point registers)");
16820       case NT_PSINFO:
16821         return _("NT_PSINFO (psinfo structure)");
16822       case NT_LWPSTATUS:
16823         return _("NT_LWPSTATUS (lwpstatus_t structure)");
16824       case NT_LWPSINFO:
16825         return _("NT_LWPSINFO (lwpsinfo_t structure)");
16826       case NT_WIN32PSTATUS:
16827         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16828       case NT_SIGINFO:
16829         return _("NT_SIGINFO (siginfo_t data)");
16830       case NT_FILE:
16831         return _("NT_FILE (mapped files)");
16832       default:
16833         break;
16834       }
16835   else
16836     switch (e_type)
16837       {
16838       case NT_VERSION:
16839         return _("NT_VERSION (version)");
16840       case NT_ARCH:
16841         return _("NT_ARCH (architecture)");
16842       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16843         return _("OPEN");
16844       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16845         return _("func");
16846       default:
16847         break;
16848       }
16849
16850   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16851   return buff;
16852 }
16853
16854 static bfd_boolean
16855 print_core_note (Elf_Internal_Note *pnote)
16856 {
16857   unsigned int addr_size = is_32bit_elf ? 4 : 8;
16858   bfd_vma count, page_size;
16859   unsigned char *descdata, *filenames, *descend;
16860
16861   if (pnote->type != NT_FILE)
16862     {
16863       if (do_wide)
16864         printf ("\n");
16865       return TRUE;
16866     }
16867
16868 #ifndef BFD64
16869   if (!is_32bit_elf)
16870     {
16871       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
16872       /* Still "successful".  */
16873       return TRUE;
16874     }
16875 #endif
16876
16877   if (pnote->descsz < 2 * addr_size)
16878     {
16879       error (_("    Malformed note - too short for header\n"));
16880       return FALSE;
16881     }
16882
16883   descdata = (unsigned char *) pnote->descdata;
16884   descend = descdata + pnote->descsz;
16885
16886   if (descdata[pnote->descsz - 1] != '\0')
16887     {
16888       error (_("    Malformed note - does not end with \\0\n"));
16889       return FALSE;
16890     }
16891
16892   count = byte_get (descdata, addr_size);
16893   descdata += addr_size;
16894
16895   page_size = byte_get (descdata, addr_size);
16896   descdata += addr_size;
16897
16898   if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
16899       || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16900     {
16901       error (_("    Malformed note - too short for supplied file count\n"));
16902       return FALSE;
16903     }
16904
16905   printf (_("    Page size: "));
16906   print_vma (page_size, DEC);
16907   printf ("\n");
16908
16909   printf (_("    %*s%*s%*s\n"),
16910           (int) (2 + 2 * addr_size), _("Start"),
16911           (int) (4 + 2 * addr_size), _("End"),
16912           (int) (4 + 2 * addr_size), _("Page Offset"));
16913   filenames = descdata + count * 3 * addr_size;
16914   while (count-- > 0)
16915     {
16916       bfd_vma start, end, file_ofs;
16917
16918       if (filenames == descend)
16919         {
16920           error (_("    Malformed note - filenames end too early\n"));
16921           return FALSE;
16922         }
16923
16924       start = byte_get (descdata, addr_size);
16925       descdata += addr_size;
16926       end = byte_get (descdata, addr_size);
16927       descdata += addr_size;
16928       file_ofs = byte_get (descdata, addr_size);
16929       descdata += addr_size;
16930
16931       printf ("    ");
16932       print_vma (start, FULL_HEX);
16933       printf ("  ");
16934       print_vma (end, FULL_HEX);
16935       printf ("  ");
16936       print_vma (file_ofs, FULL_HEX);
16937       printf ("\n        %s\n", filenames);
16938
16939       filenames += 1 + strlen ((char *) filenames);
16940     }
16941
16942   return TRUE;
16943 }
16944
16945 static const char *
16946 get_gnu_elf_note_type (unsigned e_type)
16947 {
16948   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
16949   switch (e_type)
16950     {
16951     case NT_GNU_ABI_TAG:
16952       return _("NT_GNU_ABI_TAG (ABI version tag)");
16953     case NT_GNU_HWCAP:
16954       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16955     case NT_GNU_BUILD_ID:
16956       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16957     case NT_GNU_GOLD_VERSION:
16958       return _("NT_GNU_GOLD_VERSION (gold version)");
16959     case NT_GNU_PROPERTY_TYPE_0:
16960       return _("NT_GNU_PROPERTY_TYPE_0");
16961     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16962       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16963     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16964       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16965     default:
16966       {
16967         static char buff[64];
16968
16969         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16970         return buff;
16971       }
16972     }
16973 }
16974
16975 static void
16976 decode_x86_compat_isa (unsigned int bitmask)
16977 {
16978   while (bitmask)
16979     {
16980       unsigned int bit = bitmask & (- bitmask);
16981
16982       bitmask &= ~ bit;
16983       switch (bit)
16984         {
16985         case GNU_PROPERTY_X86_COMPAT_ISA_1_486:
16986           printf ("i486");
16987           break;
16988         case GNU_PROPERTY_X86_COMPAT_ISA_1_586:
16989           printf ("586");
16990           break;
16991         case GNU_PROPERTY_X86_COMPAT_ISA_1_686:
16992           printf ("686");
16993           break;
16994         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE:
16995           printf ("SSE");
16996           break;
16997         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2:
16998           printf ("SSE2");
16999           break;
17000         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3:
17001           printf ("SSE3");
17002           break;
17003         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3:
17004           printf ("SSSE3");
17005           break;
17006         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1:
17007           printf ("SSE4_1");
17008           break;
17009         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2:
17010           printf ("SSE4_2");
17011           break;
17012         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX:
17013           printf ("AVX");
17014           break;
17015         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2:
17016           printf ("AVX2");
17017           break;
17018         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F:
17019           printf ("AVX512F");
17020           break;
17021         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD:
17022           printf ("AVX512CD");
17023           break;
17024         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER:
17025           printf ("AVX512ER");
17026           break;
17027         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF:
17028           printf ("AVX512PF");
17029           break;
17030         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL:
17031           printf ("AVX512VL");
17032           break;
17033         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ:
17034           printf ("AVX512DQ");
17035           break;
17036         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW:
17037           printf ("AVX512BW");
17038           break;
17039         default:
17040           printf (_("<unknown: %x>"), bit);
17041           break;
17042         }
17043       if (bitmask)
17044         printf (", ");
17045     }
17046 }
17047
17048 static void
17049 decode_x86_isa (unsigned int bitmask)
17050 {
17051   if (bitmask == GNU_PROPERTY_X86_UINT32_VALID)
17052     {
17053       printf (_("<None>"));
17054       return;
17055     }
17056   else
17057     bitmask &= ~GNU_PROPERTY_X86_UINT32_VALID;
17058
17059   while (bitmask)
17060     {
17061       unsigned int bit = bitmask & (- bitmask);
17062
17063       bitmask &= ~ bit;
17064       switch (bit)
17065         {
17066         case GNU_PROPERTY_X86_ISA_1_CMOV:
17067           printf ("CMOV");
17068           break;
17069         case GNU_PROPERTY_X86_ISA_1_SSE:
17070           printf ("SSE");
17071           break;
17072         case GNU_PROPERTY_X86_ISA_1_SSE2:
17073           printf ("SSE2");
17074           break;
17075         case GNU_PROPERTY_X86_ISA_1_SSE3:
17076           printf ("SSE3");
17077           break;
17078         case GNU_PROPERTY_X86_ISA_1_SSSE3:
17079           printf ("SSSE3");
17080           break;
17081         case GNU_PROPERTY_X86_ISA_1_SSE4_1:
17082           printf ("SSE4_1");
17083           break;
17084         case GNU_PROPERTY_X86_ISA_1_SSE4_2:
17085           printf ("SSE4_2");
17086           break;
17087         case GNU_PROPERTY_X86_ISA_1_AVX:
17088           printf ("AVX");
17089           break;
17090         case GNU_PROPERTY_X86_ISA_1_AVX2:
17091           printf ("AVX2");
17092           break;
17093         case GNU_PROPERTY_X86_ISA_1_FMA:
17094           printf ("FMA");
17095           break;
17096         case GNU_PROPERTY_X86_ISA_1_AVX512F:
17097           printf ("AVX512F");
17098           break;
17099         case GNU_PROPERTY_X86_ISA_1_AVX512CD:
17100           printf ("AVX512CD");
17101           break;
17102         case GNU_PROPERTY_X86_ISA_1_AVX512ER:
17103           printf ("AVX512ER");
17104           break;
17105         case GNU_PROPERTY_X86_ISA_1_AVX512PF:
17106           printf ("AVX512PF");
17107           break;
17108         case GNU_PROPERTY_X86_ISA_1_AVX512VL:
17109           printf ("AVX512VL");
17110           break;
17111         case GNU_PROPERTY_X86_ISA_1_AVX512DQ:
17112           printf ("AVX512DQ");
17113           break;
17114         case GNU_PROPERTY_X86_ISA_1_AVX512BW:
17115           printf ("AVX512BW");
17116           break;
17117         case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS:
17118           printf ("AVX512_4FMAPS");
17119           break;
17120         case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW:
17121           printf ("AVX512_4VNNIW");
17122           break;
17123         case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG:
17124           printf ("AVX512_BITALG");
17125           break;
17126         case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA:
17127           printf ("AVX512_IFMA");
17128           break;
17129         case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI:
17130           printf ("AVX512_VBMI");
17131           break;
17132         case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2:
17133           printf ("AVX512_VBMI2");
17134           break;
17135         case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI:
17136           printf ("AVX512_VNNI");
17137           break;
17138         default:
17139           printf (_("<unknown: %x>"), bit);
17140           break;
17141         }
17142       if (bitmask)
17143         printf (", ");
17144     }
17145 }
17146
17147 static void
17148 decode_x86_feature_1 (unsigned int bitmask)
17149 {
17150   if (bitmask == GNU_PROPERTY_X86_UINT32_VALID)
17151     {
17152       printf (_("<None>"));
17153       return;
17154     }
17155   else
17156     bitmask &= ~GNU_PROPERTY_X86_UINT32_VALID;
17157
17158   while (bitmask)
17159     {
17160       unsigned int bit = bitmask & (- bitmask);
17161
17162       bitmask &= ~ bit;
17163       switch (bit)
17164         {
17165         case GNU_PROPERTY_X86_FEATURE_1_IBT:
17166           printf ("IBT");
17167           break;
17168         case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
17169           printf ("SHSTK");
17170           break;
17171         default:
17172           printf (_("<unknown: %x>"), bit);
17173           break;
17174         }
17175       if (bitmask)
17176         printf (", ");
17177     }
17178 }
17179
17180 static void
17181 decode_x86_feature_2 (unsigned int bitmask)
17182 {
17183   if (bitmask == GNU_PROPERTY_X86_UINT32_VALID)
17184     {
17185       printf (_("<None>"));
17186       return;
17187     }
17188   else
17189     bitmask &= ~GNU_PROPERTY_X86_UINT32_VALID;
17190
17191   while (bitmask)
17192     {
17193       unsigned int bit = bitmask & (- bitmask);
17194
17195       bitmask &= ~ bit;
17196       switch (bit)
17197         {
17198         case GNU_PROPERTY_X86_FEATURE_2_X86:
17199           printf ("x86");
17200           break;
17201         case GNU_PROPERTY_X86_FEATURE_2_X87:
17202           printf ("x87");
17203           break;
17204         case GNU_PROPERTY_X86_FEATURE_2_MMX:
17205           printf ("MMX");
17206           break;
17207         case GNU_PROPERTY_X86_FEATURE_2_XMM:
17208           printf ("XMM");
17209           break;
17210         case GNU_PROPERTY_X86_FEATURE_2_YMM:
17211           printf ("YMM");
17212           break;
17213         case GNU_PROPERTY_X86_FEATURE_2_ZMM:
17214           printf ("ZMM");
17215           break;
17216         case GNU_PROPERTY_X86_FEATURE_2_FXSR:
17217           printf ("FXSR");
17218           break;
17219         case GNU_PROPERTY_X86_FEATURE_2_XSAVE:
17220           printf ("XSAVE");
17221           break;
17222         case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT:
17223           printf ("XSAVEOPT");
17224           break;
17225         case GNU_PROPERTY_X86_FEATURE_2_XSAVEC:
17226           printf ("XSAVEC");
17227           break;
17228         default:
17229           printf (_("<unknown: %x>"), bit);
17230           break;
17231         }
17232       if (bitmask)
17233         printf (", ");
17234     }
17235 }
17236
17237 static void
17238 print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
17239 {
17240   unsigned char * ptr = (unsigned char *) pnote->descdata;
17241   unsigned char * ptr_end = ptr + pnote->descsz;
17242   unsigned int    size = is_32bit_elf ? 4 : 8;
17243
17244   printf (_("      Properties: "));
17245
17246   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
17247     {
17248       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
17249       return;
17250     }
17251
17252   while (ptr < ptr_end)
17253     {
17254       unsigned int j;
17255       unsigned int type;
17256       unsigned int datasz;
17257
17258       if ((size_t) (ptr_end - ptr) < 8)
17259         {
17260           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
17261           break;
17262         }
17263
17264       type = byte_get (ptr, 4);
17265       datasz = byte_get (ptr + 4, 4);
17266
17267       ptr += 8;
17268
17269       if (datasz > (size_t) (ptr_end - ptr))
17270         {
17271           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17272                   type, datasz);
17273           break;
17274         }
17275
17276       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
17277         {
17278           if (filedata->file_header.e_machine == EM_X86_64
17279               || filedata->file_header.e_machine == EM_IAMCU
17280               || filedata->file_header.e_machine == EM_386)
17281             {
17282               unsigned int bitmask;
17283
17284               if (datasz == 4)
17285                 {
17286                   bitmask = byte_get (ptr, 4);
17287                   if ((filedata->file_header.e_type == ET_EXEC
17288                        || filedata->file_header.e_type == ET_DYN)
17289                       && !(bitmask & GNU_PROPERTY_X86_UINT32_VALID))
17290                     printf ("Invalid ");
17291                 }
17292               else
17293                 bitmask = 0;
17294
17295               switch (type)
17296                 {
17297                 case GNU_PROPERTY_X86_ISA_1_USED:
17298                   if (datasz != 4)
17299                     printf (_("x86 ISA used: <corrupt length: %#x> "),
17300                             datasz);
17301                   else
17302                     {
17303                       printf ("x86 ISA used: ");
17304                       decode_x86_isa (bitmask);
17305                     }
17306                   goto next;
17307
17308                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
17309                   if (datasz != 4)
17310                     printf (_("x86 ISA needed: <corrupt length: %#x> "),
17311                             datasz);
17312                   else
17313                     {
17314                       printf ("x86 ISA needed: ");
17315                       decode_x86_isa (bitmask);
17316                     }
17317                   goto next;
17318
17319                 case GNU_PROPERTY_X86_FEATURE_1_AND:
17320                   if (datasz != 4)
17321                     printf (_("x86 feature: <corrupt length: %#x> "),
17322                             datasz);
17323                   else
17324                     {
17325                       printf ("x86 feature: ");
17326                       decode_x86_feature_1 (bitmask);
17327                     }
17328                   goto next;
17329
17330                 case GNU_PROPERTY_X86_FEATURE_2_USED:
17331                   if (datasz != 4)
17332                     printf (_("x86 feature used: <corrupt length: %#x> "),
17333                             datasz);
17334                   else
17335                     {
17336                       printf ("x86 feature used: ");
17337                       decode_x86_feature_2 (bitmask);
17338                     }
17339                   goto next;
17340
17341                 case GNU_PROPERTY_X86_FEATURE_2_NEEDED:
17342                   if (datasz != 4)
17343                     printf (_("x86 feature needed: <corrupt length: %#x> "), datasz);
17344                   else
17345                     {
17346                       printf ("x86 feature needed: ");
17347                       decode_x86_feature_2 (bitmask);
17348                     }
17349                   goto next;
17350
17351                 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED:
17352                   if (datasz != 4)
17353                     printf (_("x86 ISA used: <corrupt length: %#x> "),
17354                             datasz);
17355                   else
17356                     {
17357                       printf ("x86 ISA used: ");
17358                       decode_x86_compat_isa (bitmask);
17359                     }
17360                   goto next;
17361
17362                 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED:
17363                   if (datasz != 4)
17364                     printf (_("x86 ISA needed: <corrupt length: %#x> "),
17365                             datasz);
17366                   else
17367                     {
17368                       printf ("x86 ISA needed: ");
17369                       decode_x86_compat_isa (bitmask);
17370                     }
17371                   goto next;
17372
17373                 default:
17374                   break;
17375                 }
17376             }
17377         }
17378       else
17379         {
17380           switch (type)
17381             {
17382             case GNU_PROPERTY_STACK_SIZE:
17383               printf (_("stack size: "));
17384               if (datasz != size)
17385                 printf (_("<corrupt length: %#x> "), datasz);
17386               else
17387                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
17388               goto next;
17389
17390             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
17391               printf ("no copy on protected ");
17392               if (datasz)
17393                 printf (_("<corrupt length: %#x> "), datasz);
17394               goto next;
17395
17396             default:
17397               break;
17398             }
17399         }
17400
17401       if (type < GNU_PROPERTY_LOPROC)
17402         printf (_("<unknown type %#x data: "), type);
17403       else if (type < GNU_PROPERTY_LOUSER)
17404         printf (_("<procesor-specific type %#x data: "), type);
17405       else
17406         printf (_("<application-specific type %#x data: "), type);
17407       for (j = 0; j < datasz; ++j)
17408         printf ("%02x ", ptr[j] & 0xff);
17409       printf (">");
17410
17411 next:
17412       ptr += ((datasz + (size - 1)) & ~ (size - 1));
17413       if (ptr == ptr_end)
17414         break;
17415
17416       if (do_wide)
17417         printf (", ");
17418       else
17419         printf ("\n\t");
17420     }
17421
17422   printf ("\n");
17423 }
17424
17425 static bfd_boolean
17426 print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
17427 {
17428   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
17429   switch (pnote->type)
17430     {
17431     case NT_GNU_BUILD_ID:
17432       {
17433         unsigned long i;
17434
17435         printf (_("    Build ID: "));
17436         for (i = 0; i < pnote->descsz; ++i)
17437           printf ("%02x", pnote->descdata[i] & 0xff);
17438         printf ("\n");
17439       }
17440       break;
17441
17442     case NT_GNU_ABI_TAG:
17443       {
17444         unsigned long os, major, minor, subminor;
17445         const char *osname;
17446
17447         /* PR 17531: file: 030-599401-0.004.  */
17448         if (pnote->descsz < 16)
17449           {
17450             printf (_("    <corrupt GNU_ABI_TAG>\n"));
17451             break;
17452           }
17453
17454         os = byte_get ((unsigned char *) pnote->descdata, 4);
17455         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17456         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
17457         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
17458
17459         switch (os)
17460           {
17461           case GNU_ABI_TAG_LINUX:
17462             osname = "Linux";
17463             break;
17464           case GNU_ABI_TAG_HURD:
17465             osname = "Hurd";
17466             break;
17467           case GNU_ABI_TAG_SOLARIS:
17468             osname = "Solaris";
17469             break;
17470           case GNU_ABI_TAG_FREEBSD:
17471             osname = "FreeBSD";
17472             break;
17473           case GNU_ABI_TAG_NETBSD:
17474             osname = "NetBSD";
17475             break;
17476           case GNU_ABI_TAG_SYLLABLE:
17477             osname = "Syllable";
17478             break;
17479           case GNU_ABI_TAG_NACL:
17480             osname = "NaCl";
17481             break;
17482           default:
17483             osname = "Unknown";
17484             break;
17485           }
17486
17487         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
17488                 major, minor, subminor);
17489       }
17490       break;
17491
17492     case NT_GNU_GOLD_VERSION:
17493       {
17494         unsigned long i;
17495
17496         printf (_("    Version: "));
17497         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
17498           printf ("%c", pnote->descdata[i]);
17499         printf ("\n");
17500       }
17501       break;
17502
17503     case NT_GNU_HWCAP:
17504       {
17505         unsigned long num_entries, mask;
17506
17507         /* Hardware capabilities information.  Word 0 is the number of entries.
17508            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
17509            is a series of entries, where each entry is a single byte followed
17510            by a nul terminated string.  The byte gives the bit number to test
17511            if enabled in the bitmask.  */
17512         printf (_("      Hardware Capabilities: "));
17513         if (pnote->descsz < 8)
17514           {
17515             error (_("<corrupt GNU_HWCAP>\n"));
17516             return FALSE;
17517           }
17518         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
17519         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17520         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
17521         /* FIXME: Add code to display the entries... */
17522       }
17523       break;
17524
17525     case NT_GNU_PROPERTY_TYPE_0:
17526       print_gnu_property_note (filedata, pnote);
17527       break;
17528
17529     default:
17530       /* Handle unrecognised types.  An error message should have already been
17531          created by get_gnu_elf_note_type(), so all that we need to do is to
17532          display the data.  */
17533       {
17534         unsigned long i;
17535
17536         printf (_("    Description data: "));
17537         for (i = 0; i < pnote->descsz; ++i)
17538           printf ("%02x ", pnote->descdata[i] & 0xff);
17539         printf ("\n");
17540       }
17541       break;
17542     }
17543
17544   return TRUE;
17545 }
17546
17547 static const char *
17548 get_v850_elf_note_type (enum v850_notes n_type)
17549 {
17550   static char buff[64];
17551
17552   switch (n_type)
17553     {
17554     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
17555     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
17556     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
17557     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
17558     case V850_NOTE_CACHE_INFO: return _("Use of cache");
17559     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
17560     default:
17561       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
17562       return buff;
17563     }
17564 }
17565
17566 static bfd_boolean
17567 print_v850_note (Elf_Internal_Note * pnote)
17568 {
17569   unsigned int val;
17570
17571   if (pnote->descsz != 4)
17572     return FALSE;
17573
17574   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
17575
17576   if (val == 0)
17577     {
17578       printf (_("not set\n"));
17579       return TRUE;
17580     }
17581
17582   switch (pnote->type)
17583     {
17584     case V850_NOTE_ALIGNMENT:
17585       switch (val)
17586         {
17587         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
17588         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
17589         }
17590       break;
17591
17592     case V850_NOTE_DATA_SIZE:
17593       switch (val)
17594         {
17595         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
17596         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
17597         }
17598       break;
17599
17600     case V850_NOTE_FPU_INFO:
17601       switch (val)
17602         {
17603         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
17604         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
17605         }
17606       break;
17607
17608     case V850_NOTE_MMU_INFO:
17609     case V850_NOTE_CACHE_INFO:
17610     case V850_NOTE_SIMD_INFO:
17611       if (val == EF_RH850_SIMD)
17612         {
17613           printf (_("yes\n"));
17614           return TRUE;
17615         }
17616       break;
17617
17618     default:
17619       /* An 'unknown note type' message will already have been displayed.  */
17620       break;
17621     }
17622
17623   printf (_("unknown value: %x\n"), val);
17624   return FALSE;
17625 }
17626
17627 static bfd_boolean
17628 process_netbsd_elf_note (Elf_Internal_Note * pnote)
17629 {
17630   unsigned int version;
17631
17632   switch (pnote->type)
17633     {
17634     case NT_NETBSD_IDENT:
17635       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
17636       if ((version / 10000) % 100)
17637         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
17638                 version, version / 100000000, (version / 1000000) % 100,
17639                 (version / 10000) % 100 > 26 ? "Z" : "",
17640                 'A' + (version / 10000) % 26);
17641       else
17642         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
17643                 version, version / 100000000, (version / 1000000) % 100,
17644                 (version / 100) % 100);
17645       return TRUE;
17646
17647     case NT_NETBSD_MARCH:
17648       printf ("  NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
17649               pnote->descdata);
17650       return TRUE;
17651
17652     default:
17653       printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
17654               pnote->type);
17655       return FALSE;
17656     }
17657 }
17658
17659 static const char *
17660 get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17661 {
17662   switch (e_type)
17663     {
17664     case NT_FREEBSD_THRMISC:
17665       return _("NT_THRMISC (thrmisc structure)");
17666     case NT_FREEBSD_PROCSTAT_PROC:
17667       return _("NT_PROCSTAT_PROC (proc data)");
17668     case NT_FREEBSD_PROCSTAT_FILES:
17669       return _("NT_PROCSTAT_FILES (files data)");
17670     case NT_FREEBSD_PROCSTAT_VMMAP:
17671       return _("NT_PROCSTAT_VMMAP (vmmap data)");
17672     case NT_FREEBSD_PROCSTAT_GROUPS:
17673       return _("NT_PROCSTAT_GROUPS (groups data)");
17674     case NT_FREEBSD_PROCSTAT_UMASK:
17675       return _("NT_PROCSTAT_UMASK (umask data)");
17676     case NT_FREEBSD_PROCSTAT_RLIMIT:
17677       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17678     case NT_FREEBSD_PROCSTAT_OSREL:
17679       return _("NT_PROCSTAT_OSREL (osreldate data)");
17680     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
17681       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17682     case NT_FREEBSD_PROCSTAT_AUXV:
17683       return _("NT_PROCSTAT_AUXV (auxv data)");
17684     case NT_FREEBSD_PTLWPINFO:
17685       return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17686     }
17687   return get_note_type (filedata, e_type);
17688 }
17689
17690 static const char *
17691 get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17692 {
17693   static char buff[64];
17694
17695   if (e_type == NT_NETBSDCORE_PROCINFO)
17696     return _("NetBSD procinfo structure");
17697
17698   /* As of Jan 2002 there are no other machine-independent notes
17699      defined for NetBSD core files.  If the note type is less
17700      than the start of the machine-dependent note types, we don't
17701      understand it.  */
17702
17703   if (e_type < NT_NETBSDCORE_FIRSTMACH)
17704     {
17705       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17706       return buff;
17707     }
17708
17709   switch (filedata->file_header.e_machine)
17710     {
17711     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17712        and PT_GETFPREGS == mach+2.  */
17713
17714     case EM_OLD_ALPHA:
17715     case EM_ALPHA:
17716     case EM_SPARC:
17717     case EM_SPARC32PLUS:
17718     case EM_SPARCV9:
17719       switch (e_type)
17720         {
17721         case NT_NETBSDCORE_FIRSTMACH + 0:
17722           return _("PT_GETREGS (reg structure)");
17723         case NT_NETBSDCORE_FIRSTMACH + 2:
17724           return _("PT_GETFPREGS (fpreg structure)");
17725         default:
17726           break;
17727         }
17728       break;
17729
17730     /* On all other arch's, PT_GETREGS == mach+1 and
17731        PT_GETFPREGS == mach+3.  */
17732     default:
17733       switch (e_type)
17734         {
17735         case NT_NETBSDCORE_FIRSTMACH + 1:
17736           return _("PT_GETREGS (reg structure)");
17737         case NT_NETBSDCORE_FIRSTMACH + 3:
17738           return _("PT_GETFPREGS (fpreg structure)");
17739         default:
17740           break;
17741         }
17742     }
17743
17744   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
17745             e_type - NT_NETBSDCORE_FIRSTMACH);
17746   return buff;
17747 }
17748
17749 static const char *
17750 get_stapsdt_note_type (unsigned e_type)
17751 {
17752   static char buff[64];
17753
17754   switch (e_type)
17755     {
17756     case NT_STAPSDT:
17757       return _("NT_STAPSDT (SystemTap probe descriptors)");
17758
17759     default:
17760       break;
17761     }
17762
17763   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17764   return buff;
17765 }
17766
17767 static bfd_boolean
17768 print_stapsdt_note (Elf_Internal_Note *pnote)
17769 {
17770   int addr_size = is_32bit_elf ? 4 : 8;
17771   char *data = pnote->descdata;
17772   char *data_end = pnote->descdata + pnote->descsz;
17773   bfd_vma pc, base_addr, semaphore;
17774   char *provider, *probe, *arg_fmt;
17775
17776   pc = byte_get ((unsigned char *) data, addr_size);
17777   data += addr_size;
17778   base_addr = byte_get ((unsigned char *) data, addr_size);
17779   data += addr_size;
17780   semaphore = byte_get ((unsigned char *) data, addr_size);
17781   data += addr_size;
17782
17783   provider = data;
17784   data += strlen (data) + 1;
17785   probe = data;
17786   data += strlen (data) + 1;
17787   arg_fmt = data;
17788   data += strlen (data) + 1;
17789
17790   printf (_("    Provider: %s\n"), provider);
17791   printf (_("    Name: %s\n"), probe);
17792   printf (_("    Location: "));
17793   print_vma (pc, FULL_HEX);
17794   printf (_(", Base: "));
17795   print_vma (base_addr, FULL_HEX);
17796   printf (_(", Semaphore: "));
17797   print_vma (semaphore, FULL_HEX);
17798   printf ("\n");
17799   printf (_("    Arguments: %s\n"), arg_fmt);
17800
17801   return data == data_end;
17802 }
17803
17804 static const char *
17805 get_ia64_vms_note_type (unsigned e_type)
17806 {
17807   static char buff[64];
17808
17809   switch (e_type)
17810     {
17811     case NT_VMS_MHD:
17812       return _("NT_VMS_MHD (module header)");
17813     case NT_VMS_LNM:
17814       return _("NT_VMS_LNM (language name)");
17815     case NT_VMS_SRC:
17816       return _("NT_VMS_SRC (source files)");
17817     case NT_VMS_TITLE:
17818       return "NT_VMS_TITLE";
17819     case NT_VMS_EIDC:
17820       return _("NT_VMS_EIDC (consistency check)");
17821     case NT_VMS_FPMODE:
17822       return _("NT_VMS_FPMODE (FP mode)");
17823     case NT_VMS_LINKTIME:
17824       return "NT_VMS_LINKTIME";
17825     case NT_VMS_IMGNAM:
17826       return _("NT_VMS_IMGNAM (image name)");
17827     case NT_VMS_IMGID:
17828       return _("NT_VMS_IMGID (image id)");
17829     case NT_VMS_LINKID:
17830       return _("NT_VMS_LINKID (link id)");
17831     case NT_VMS_IMGBID:
17832       return _("NT_VMS_IMGBID (build id)");
17833     case NT_VMS_GSTNAM:
17834       return _("NT_VMS_GSTNAM (sym table name)");
17835     case NT_VMS_ORIG_DYN:
17836       return "NT_VMS_ORIG_DYN";
17837     case NT_VMS_PATCHTIME:
17838       return "NT_VMS_PATCHTIME";
17839     default:
17840       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17841       return buff;
17842     }
17843 }
17844
17845 static bfd_boolean
17846 print_ia64_vms_note (Elf_Internal_Note * pnote)
17847 {
17848   switch (pnote->type)
17849     {
17850     case NT_VMS_MHD:
17851       if (pnote->descsz > 36)
17852         {
17853           size_t l = strlen (pnote->descdata + 34);
17854           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
17855           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
17856           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
17857           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
17858         }
17859       else
17860         printf (_("    Invalid size\n"));
17861       break;
17862     case NT_VMS_LNM:
17863       printf (_("   Language: %s\n"), pnote->descdata);
17864       break;
17865 #ifdef BFD64
17866     case NT_VMS_FPMODE:
17867       printf (_("   Floating Point mode: "));
17868       printf ("0x%016" BFD_VMA_FMT "x\n",
17869               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
17870       break;
17871     case NT_VMS_LINKTIME:
17872       printf (_("   Link time: "));
17873       print_vms_time
17874         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17875       printf ("\n");
17876       break;
17877     case NT_VMS_PATCHTIME:
17878       printf (_("   Patch time: "));
17879       print_vms_time
17880         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17881       printf ("\n");
17882       break;
17883     case NT_VMS_ORIG_DYN:
17884       printf (_("   Major id: %u,  minor id: %u\n"),
17885               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
17886               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
17887       printf (_("   Last modified  : "));
17888       print_vms_time
17889         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
17890       printf (_("\n   Link flags  : "));
17891       printf ("0x%016" BFD_VMA_FMT "x\n",
17892               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
17893       printf (_("   Header flags: 0x%08x\n"),
17894               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
17895       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
17896       break;
17897 #endif
17898     case NT_VMS_IMGNAM:
17899       printf (_("    Image name: %s\n"), pnote->descdata);
17900       break;
17901     case NT_VMS_GSTNAM:
17902       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
17903       break;
17904     case NT_VMS_IMGID:
17905       printf (_("    Image id: %s\n"), pnote->descdata);
17906       break;
17907     case NT_VMS_LINKID:
17908       printf (_("    Linker id: %s\n"), pnote->descdata);
17909       break;
17910     default:
17911       return FALSE;
17912     }
17913   return TRUE;
17914 }
17915
17916 /* Find the symbol associated with a build attribute that is attached
17917    to address OFFSET.  If PNAME is non-NULL then store the name of
17918    the symbol (if found) in the provided pointer,  Returns NULL if a
17919    symbol could not be found.  */
17920
17921 static Elf_Internal_Sym *
17922 get_symbol_for_build_attribute (Filedata *       filedata,
17923                                 unsigned long    offset,
17924                                 bfd_boolean      is_open_attr,
17925                                 const char **    pname)
17926 {
17927   static Filedata *         saved_filedata = NULL;
17928   static char *             strtab;
17929   static unsigned long      strtablen;
17930   static Elf_Internal_Sym * symtab;
17931   static unsigned long      nsyms;
17932   Elf_Internal_Sym *        saved_sym = NULL;
17933   Elf_Internal_Sym *        sym;
17934
17935   if (filedata->section_headers != NULL
17936       && (saved_filedata == NULL || filedata != saved_filedata))
17937     {
17938       Elf_Internal_Shdr * symsec;
17939
17940       /* Load the symbol and string sections.  */
17941       for (symsec = filedata->section_headers;
17942            symsec < filedata->section_headers + filedata->file_header.e_shnum;
17943            symsec ++)
17944         {
17945           if (symsec->sh_type == SHT_SYMTAB)
17946             {
17947               symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
17948
17949               if (symsec->sh_link < filedata->file_header.e_shnum)
17950                 {
17951                   Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
17952
17953                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
17954                                               1, strtab_sec->sh_size,
17955                                               _("string table"));
17956                   strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
17957                 }
17958             }
17959         }
17960       saved_filedata = filedata;
17961     }
17962
17963   if (symtab == NULL || strtab == NULL)
17964     return NULL;
17965
17966   /* Find a symbol whose value matches offset.  */
17967   for (sym = symtab; sym < symtab + nsyms; sym ++)
17968     if (sym->st_value == offset)
17969       {
17970         if (sym->st_name >= strtablen)
17971           /* Huh ?  This should not happen.  */
17972           continue;
17973
17974         if (strtab[sym->st_name] == 0)
17975           continue;
17976
17977         /* The AArch64 and ARM architectures define mapping symbols
17978            (eg $d, $x, $t) which we want to ignore.  */
17979         if (strtab[sym->st_name] == '$'
17980             && strtab[sym->st_name + 1] != 0
17981             && strtab[sym->st_name + 2] == 0)
17982           continue;
17983
17984         if (is_open_attr)
17985           {
17986             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17987                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
17988                FUNC symbols entirely.  */
17989             switch (ELF_ST_TYPE (sym->st_info))
17990               {
17991               case STT_OBJECT:
17992               case STT_FILE:
17993                 saved_sym = sym;
17994                 if (sym->st_size)
17995                   {
17996                     /* If the symbol has a size associated
17997                        with it then we can stop searching.  */
17998                     sym = symtab + nsyms;
17999                   }
18000                 continue;
18001
18002               case STT_FUNC:
18003                 /* Ignore function symbols.  */
18004                 continue;
18005
18006               default:
18007                 break;
18008               }
18009
18010             switch (ELF_ST_BIND (sym->st_info))
18011               {
18012               case STB_GLOBAL:
18013                 if (saved_sym == NULL
18014                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
18015                   saved_sym = sym;
18016                 break;
18017
18018               case STB_LOCAL:
18019                 if (saved_sym == NULL)
18020                   saved_sym = sym;
18021                 break;
18022
18023               default:
18024                 break;
18025               }
18026           }
18027         else
18028           {
18029             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
18030               continue;
18031
18032             saved_sym = sym;
18033             break;
18034           }
18035       }
18036
18037   if (saved_sym && pname)
18038     * pname = strtab + saved_sym->st_name;
18039
18040   return saved_sym;
18041 }
18042
18043 /* Returns true iff addr1 and addr2 are in the same section.  */
18044
18045 static bfd_boolean
18046 same_section (Filedata * filedata, unsigned long addr1, unsigned long addr2)
18047 {
18048   Elf_Internal_Shdr * a1;
18049   Elf_Internal_Shdr * a2;
18050
18051   a1 = find_section_by_address (filedata, addr1);
18052   a2 = find_section_by_address (filedata, addr2);
18053
18054   return a1 == a2 && a1 != NULL;
18055 }
18056
18057 static bfd_boolean
18058 print_gnu_build_attribute_description (Elf_Internal_Note *  pnote,
18059                                        Filedata *           filedata)
18060 {
18061   static unsigned long  global_offset = 0;
18062   static unsigned long  global_end = 0;
18063   static unsigned long  func_offset = 0;
18064   static unsigned long  func_end = 0;
18065
18066   Elf_Internal_Sym *    sym;
18067   const char *          name;
18068   unsigned long         start;
18069   unsigned long         end;
18070   bfd_boolean           is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
18071
18072   switch (pnote->descsz)
18073     {
18074     case 0:
18075       /* A zero-length description means that the range of
18076          the previous note of the same type should be used.  */
18077       if (is_open_attr)
18078         {
18079           if (global_end > global_offset)
18080             printf (_("    Applies to region from %#lx to %#lx\n"),
18081                     global_offset, global_end);
18082           else
18083             printf (_("    Applies to region from %#lx\n"), global_offset);
18084         }
18085       else
18086         {
18087           if (func_end > func_offset)
18088             printf (_("    Applies to region from %#lx to %#lx\n"), func_offset, func_end);
18089           else
18090             printf (_("    Applies to region from %#lx\n"), func_offset);
18091         }
18092       return TRUE;
18093
18094     case 4:
18095       start = byte_get ((unsigned char *) pnote->descdata, 4);
18096       end = 0;
18097       break;
18098
18099     case 8:
18100       if (is_32bit_elf)
18101         {
18102           /* FIXME: We should check that version 3+ notes are being used here...  */
18103           start = byte_get ((unsigned char *) pnote->descdata, 4);
18104           end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18105         }
18106       else
18107         {
18108           start = byte_get ((unsigned char *) pnote->descdata, 8);
18109           end = 0;
18110         }
18111       break;
18112
18113     case 16:
18114       start = byte_get ((unsigned char *) pnote->descdata, 8);
18115       end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
18116       break;
18117
18118     default:
18119       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
18120       printf (_("    <invalid descsz>"));
18121       return FALSE;
18122     }
18123
18124   name = NULL;
18125   sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
18126   /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18127      in order to avoid them being confused with the start address of the
18128      first function in the file...  */
18129   if (sym == NULL && is_open_attr)
18130     sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
18131                                           & name);
18132
18133   if (end == 0 && sym != NULL && sym->st_size > 0)
18134     end = start + sym->st_size;
18135
18136   if (is_open_attr)
18137     {
18138       /* FIXME: Need to properly allow for section alignment.
18139          16 is just the alignment used on x86_64.  */
18140       if (global_end > 0
18141           && start > BFD_ALIGN (global_end, 16)
18142           /* Build notes are not guaranteed to be organised in order of
18143              increasing address, but we should find the all of the notes
18144              for one section in the same place.  */
18145           && same_section (filedata, start, global_end))
18146         warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18147               global_end + 1, start - 1);
18148
18149       printf (_("    Applies to region from %#lx"), start);
18150       global_offset = start;
18151
18152       if (end)
18153         {
18154           printf (_(" to %#lx"), end);
18155           global_end = end;
18156         }
18157     }
18158   else
18159     {
18160       printf (_("    Applies to region from %#lx"), start);
18161       func_offset = start;
18162
18163       if (end)
18164         {
18165           printf (_(" to %#lx"), end);
18166           func_end = end;
18167         }
18168     }
18169
18170   if (sym && name)
18171     printf (_(" (%s)"), name);
18172
18173   printf ("\n");
18174   return TRUE;
18175 }
18176
18177 static bfd_boolean
18178 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
18179 {
18180   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
18181   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
18182   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
18183   char         name_type;
18184   char         name_attribute;
18185   const char * expected_types;
18186   const char * name = pnote->namedata;
18187   const char * text;
18188   signed int   left;
18189
18190   if (name == NULL || pnote->namesz < 2)
18191     {
18192       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18193       print_symbol (-20, _("  <corrupt name>"));
18194       return FALSE;
18195     }
18196
18197   if (do_wide)
18198     left = 28;
18199   else
18200     left = 20;
18201
18202   /* Version 2 of the spec adds a "GA" prefix to the name field.  */
18203   if (name[0] == 'G' && name[1] == 'A')
18204     {
18205       if (pnote->namesz < 4)
18206         {
18207           error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18208           print_symbol (-20, _("  <corrupt name>"));
18209           return FALSE;
18210         }
18211
18212       printf ("GA");
18213       name += 2;
18214       left -= 2;
18215     }
18216
18217   switch ((name_type = * name))
18218     {
18219     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18220     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18221     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18222     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18223       printf ("%c", * name);
18224       left --;
18225       break;
18226     default:
18227       error (_("unrecognised attribute type in name field: %d\n"), name_type);
18228       print_symbol (-20, _("<unknown name type>"));
18229       return FALSE;
18230     }
18231
18232   ++ name;
18233   text = NULL;
18234
18235   switch ((name_attribute = * name))
18236     {
18237     case GNU_BUILD_ATTRIBUTE_VERSION:
18238       text = _("<version>");
18239       expected_types = string_expected;
18240       ++ name;
18241       break;
18242     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18243       text = _("<stack prot>");
18244       expected_types = "!+*";
18245       ++ name;
18246       break;
18247     case GNU_BUILD_ATTRIBUTE_RELRO:
18248       text = _("<relro>");
18249       expected_types = bool_expected;
18250       ++ name;
18251       break;
18252     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
18253       text = _("<stack size>");
18254       expected_types = number_expected;
18255       ++ name;
18256       break;
18257     case GNU_BUILD_ATTRIBUTE_TOOL:
18258       text = _("<tool>");
18259       expected_types = string_expected;
18260       ++ name;
18261       break;
18262     case GNU_BUILD_ATTRIBUTE_ABI:
18263       text = _("<ABI>");
18264       expected_types = "$*";
18265       ++ name;
18266       break;
18267     case GNU_BUILD_ATTRIBUTE_PIC:
18268       text = _("<PIC>");
18269       expected_types = number_expected;
18270       ++ name;
18271       break;
18272     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
18273       text = _("<short enum>");
18274       expected_types = bool_expected;
18275       ++ name;
18276       break;
18277     default:
18278       if (ISPRINT (* name))
18279         {
18280           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
18281
18282           if (len > left && ! do_wide)
18283             len = left;
18284           printf ("%.*s:", len, name);
18285           left -= len;
18286           name += len;
18287         }
18288       else
18289         {
18290           static char tmpbuf [128];
18291
18292           error (_("unrecognised byte in name field: %d\n"), * name);
18293           sprintf (tmpbuf, _("<unknown:_%d>"), * name);
18294           text = tmpbuf;
18295           name ++;
18296         }
18297       expected_types = "*$!+";
18298       break;
18299     }
18300
18301   if (text)
18302     left -= printf ("%s", text);
18303
18304   if (strchr (expected_types, name_type) == NULL)
18305     warn (_("attribute does not have an expected type (%c)\n"), name_type);
18306
18307   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
18308     {
18309       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
18310              (unsigned long) pnote->namesz,
18311              (long) (name - pnote->namedata));
18312       return FALSE;
18313     }
18314
18315   if (left < 1 && ! do_wide)
18316     return TRUE;
18317
18318   switch (name_type)
18319     {
18320     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18321       {
18322         unsigned int        bytes;
18323         unsigned long long  val = 0;
18324         unsigned int        shift = 0;
18325         char *              decoded = NULL;
18326
18327         bytes = pnote->namesz - (name - pnote->namedata);
18328         if (bytes > 0)
18329           /* The -1 is because the name field is always 0 terminated, and we
18330              want to be able to ensure that the shift in the while loop below
18331              will not overflow.  */
18332           -- bytes;
18333
18334         if (bytes > sizeof (val))
18335           {
18336             error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
18337                    bytes);
18338             bytes = sizeof (val);
18339           }
18340         /* We do not bother to warn if bytes == 0 as this can
18341            happen with some early versions of the gcc plugin.  */
18342
18343         while (bytes --)
18344           {
18345             unsigned long byte = (* name ++) & 0xff;
18346
18347             val |= byte << shift;
18348             shift += 8;
18349           }
18350
18351         switch (name_attribute)
18352           {
18353           case GNU_BUILD_ATTRIBUTE_PIC:
18354             switch (val)
18355               {
18356               case 0: decoded = "static"; break;
18357               case 1: decoded = "pic"; break;
18358               case 2: decoded = "PIC"; break;
18359               case 3: decoded = "pie"; break;
18360               case 4: decoded = "PIE"; break;
18361               default: break;
18362               }
18363             break;
18364           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18365             switch (val)
18366               {
18367                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
18368               case 0: decoded = "off"; break;
18369               case 1: decoded = "on"; break;
18370               case 2: decoded = "all"; break;
18371               case 3: decoded = "strong"; break;
18372               case 4: decoded = "explicit"; break;
18373               default: break;
18374               }
18375             break;
18376           default:
18377             break;
18378           }
18379
18380         if (decoded != NULL)
18381           {
18382             print_symbol (-left, decoded);
18383             left = 0;
18384           }
18385         else if (val == 0)
18386           {
18387             printf ("0x0");
18388             left -= 3;
18389           }
18390         else
18391           {
18392             if (do_wide)
18393               left -= printf ("0x%llx", val);
18394             else
18395               left -= printf ("0x%-.*llx", left, val);
18396           }
18397       }
18398       break;
18399     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18400       left -= print_symbol (- left, name);
18401       break;
18402     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18403       left -= print_symbol (- left, "true");
18404       break;
18405     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18406       left -= print_symbol (- left, "false");
18407       break;
18408     }
18409
18410   if (do_wide && left > 0)
18411     printf ("%-*s", left, " ");
18412
18413   return TRUE;
18414 }
18415
18416 /* Note that by the ELF standard, the name field is already null byte
18417    terminated, and namesz includes the terminating null byte.
18418    I.E. the value of namesz for the name "FSF" is 4.
18419
18420    If the value of namesz is zero, there is no name present.  */
18421
18422 static bfd_boolean
18423 process_note (Elf_Internal_Note *  pnote,
18424               Filedata *           filedata)
18425 {
18426   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
18427   const char * nt;
18428
18429   if (pnote->namesz == 0)
18430     /* If there is no note name, then use the default set of
18431        note type strings.  */
18432     nt = get_note_type (filedata, pnote->type);
18433
18434   else if (const_strneq (pnote->namedata, "GNU"))
18435     /* GNU-specific object file notes.  */
18436     nt = get_gnu_elf_note_type (pnote->type);
18437
18438   else if (const_strneq (pnote->namedata, "FreeBSD"))
18439     /* FreeBSD-specific core file notes.  */
18440     nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
18441
18442   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
18443     /* NetBSD-specific core file notes.  */
18444     nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
18445
18446   else if (const_strneq (pnote->namedata, "NetBSD"))
18447     /* NetBSD-specific core file notes.  */
18448     return process_netbsd_elf_note (pnote);
18449
18450   else if (strneq (pnote->namedata, "SPU/", 4))
18451     {
18452       /* SPU-specific core file notes.  */
18453       nt = pnote->namedata + 4;
18454       name = "SPU";
18455     }
18456
18457   else if (const_strneq (pnote->namedata, "IPF/VMS"))
18458     /* VMS/ia64-specific file notes.  */
18459     nt = get_ia64_vms_note_type (pnote->type);
18460
18461   else if (const_strneq (pnote->namedata, "stapsdt"))
18462     nt = get_stapsdt_note_type (pnote->type);
18463
18464   else
18465     /* Don't recognize this note name; just use the default set of
18466        note type strings.  */
18467     nt = get_note_type (filedata, pnote->type);
18468
18469   printf ("  ");
18470
18471   if (((const_strneq (pnote->namedata, "GA")
18472         && strchr ("*$!+", pnote->namedata[2]) != NULL)
18473        || strchr ("*$!+", pnote->namedata[0]) != NULL)
18474       && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18475           || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18476     print_gnu_build_attribute_name (pnote);
18477   else
18478     print_symbol (-20, name);
18479
18480   if (do_wide)
18481     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
18482   else
18483     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
18484
18485   if (const_strneq (pnote->namedata, "IPF/VMS"))
18486     return print_ia64_vms_note (pnote);
18487   else if (const_strneq (pnote->namedata, "GNU"))
18488     return print_gnu_note (filedata, pnote);
18489   else if (const_strneq (pnote->namedata, "stapsdt"))
18490     return print_stapsdt_note (pnote);
18491   else if (const_strneq (pnote->namedata, "CORE"))
18492     return print_core_note (pnote);
18493   else if (((const_strneq (pnote->namedata, "GA")
18494              && strchr ("*$!+", pnote->namedata[2]) != NULL)
18495             || strchr ("*$!+", pnote->namedata[0]) != NULL)
18496            && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18497                || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18498     return print_gnu_build_attribute_description (pnote, filedata);
18499
18500   if (pnote->descsz)
18501     {
18502       unsigned long i;
18503
18504       printf (_("   description data: "));
18505       for (i = 0; i < pnote->descsz; i++)
18506         printf ("%02x ", pnote->descdata[i]);
18507       if (!do_wide)
18508         printf ("\n");
18509     }
18510
18511   if (do_wide)
18512     printf ("\n");
18513
18514   return TRUE;
18515 }
18516
18517 static bfd_boolean
18518 process_notes_at (Filedata *           filedata,
18519                   Elf_Internal_Shdr *  section,
18520                   bfd_vma              offset,
18521                   bfd_vma              length,
18522                   bfd_vma              align)
18523 {
18524   Elf_External_Note * pnotes;
18525   Elf_External_Note * external;
18526   char *              end;
18527   bfd_boolean         res = TRUE;
18528
18529   if (length <= 0)
18530     return FALSE;
18531
18532   if (section)
18533     {
18534       pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
18535       if (pnotes)
18536         {
18537           if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
18538             return FALSE;
18539         }
18540     }
18541   else
18542     pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18543                                              _("notes"));
18544
18545   if (pnotes == NULL)
18546     return FALSE;
18547
18548   external = pnotes;
18549
18550   if (section)
18551     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
18552   else
18553     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18554             (unsigned long) offset, (unsigned long) length);
18555
18556   /* NB: Some note sections may have alignment value of 0 or 1.  gABI
18557      specifies that notes should be aligned to 4 bytes in 32-bit
18558      objects and to 8 bytes in 64-bit objects.  As a Linux extension,
18559      we also support 4 byte alignment in 64-bit objects.  If section
18560      alignment is less than 4, we treate alignment as 4 bytes.   */
18561   if (align < 4)
18562     align = 4;
18563   else if (align != 4 && align != 8)
18564     {
18565       warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18566             (long) align);
18567       return FALSE;
18568     }
18569
18570   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18571
18572   end = (char *) pnotes + length;
18573   while ((char *) external < end)
18574     {
18575       Elf_Internal_Note inote;
18576       size_t min_notesz;
18577       char * next;
18578       char * temp = NULL;
18579       size_t data_remaining = end - (char *) external;
18580
18581       if (!is_ia64_vms (filedata))
18582         {
18583           /* PR binutils/15191
18584              Make sure that there is enough data to read.  */
18585           min_notesz = offsetof (Elf_External_Note, name);
18586           if (data_remaining < min_notesz)
18587             {
18588               warn (ngettext ("Corrupt note: only %ld byte remains, "
18589                               "not enough for a full note\n",
18590                               "Corrupt note: only %ld bytes remain, "
18591                               "not enough for a full note\n",
18592                               data_remaining),
18593                     (long) data_remaining);
18594               break;
18595             }
18596           data_remaining -= min_notesz;
18597
18598           inote.type     = BYTE_GET (external->type);
18599           inote.namesz   = BYTE_GET (external->namesz);
18600           inote.namedata = external->name;
18601           inote.descsz   = BYTE_GET (external->descsz);
18602           inote.descdata = ((char *) external
18603                             + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
18604           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18605           next = ((char *) external
18606                   + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
18607         }
18608       else
18609         {
18610           Elf64_External_VMS_Note *vms_external;
18611
18612           /* PR binutils/15191
18613              Make sure that there is enough data to read.  */
18614           min_notesz = offsetof (Elf64_External_VMS_Note, name);
18615           if (data_remaining < min_notesz)
18616             {
18617               warn (ngettext ("Corrupt note: only %ld byte remains, "
18618                               "not enough for a full note\n",
18619                               "Corrupt note: only %ld bytes remain, "
18620                               "not enough for a full note\n",
18621                               data_remaining),
18622                     (long) data_remaining);
18623               break;
18624             }
18625           data_remaining -= min_notesz;
18626
18627           vms_external = (Elf64_External_VMS_Note *) external;
18628           inote.type     = BYTE_GET (vms_external->type);
18629           inote.namesz   = BYTE_GET (vms_external->namesz);
18630           inote.namedata = vms_external->name;
18631           inote.descsz   = BYTE_GET (vms_external->descsz);
18632           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
18633           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18634           next = inote.descdata + align_power (inote.descsz, 3);
18635         }
18636
18637       /* PR 17531: file: 3443835e.  */
18638       /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
18639       if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
18640           || (size_t) (inote.descdata - inote.namedata) > data_remaining
18641           || (size_t) (next - inote.descdata) < inote.descsz
18642           || ((size_t) (next - inote.descdata)
18643               > data_remaining - (size_t) (inote.descdata - inote.namedata)))
18644         {
18645           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18646                 (unsigned long) ((char *) external - (char *) pnotes));
18647           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18648                 inote.type, inote.namesz, inote.descsz, (int) align);
18649           break;
18650         }
18651
18652       external = (Elf_External_Note *) next;
18653
18654       /* Verify that name is null terminated.  It appears that at least
18655          one version of Linux (RedHat 6.0) generates corefiles that don't
18656          comply with the ELF spec by failing to include the null byte in
18657          namesz.  */
18658       if (inote.namedata[inote.namesz - 1] != '\0')
18659         {
18660           if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
18661             {
18662               temp = (char *) malloc (inote.namesz + 1);
18663               if (temp == NULL)
18664                 {
18665                   error (_("Out of memory allocating space for inote name\n"));
18666                   res = FALSE;
18667                   break;
18668                 }
18669
18670               memcpy (temp, inote.namedata, inote.namesz);
18671               inote.namedata = temp;
18672             }
18673           inote.namedata[inote.namesz] = 0;
18674         }
18675
18676       if (! process_note (& inote, filedata))
18677         res = FALSE;
18678
18679       if (temp != NULL)
18680         {
18681           free (temp);
18682           temp = NULL;
18683         }
18684     }
18685
18686   free (pnotes);
18687
18688   return res;
18689 }
18690
18691 static bfd_boolean
18692 process_corefile_note_segments (Filedata * filedata)
18693 {
18694   Elf_Internal_Phdr * segment;
18695   unsigned int i;
18696   bfd_boolean res = TRUE;
18697
18698   if (! get_program_headers (filedata))
18699     return TRUE;
18700
18701   for (i = 0, segment = filedata->program_headers;
18702        i < filedata->file_header.e_phnum;
18703        i++, segment++)
18704     {
18705       if (segment->p_type == PT_NOTE)
18706         if (! process_notes_at (filedata, NULL,
18707                                 (bfd_vma) segment->p_offset,
18708                                 (bfd_vma) segment->p_filesz,
18709                                 (bfd_vma) segment->p_align))
18710           res = FALSE;
18711     }
18712
18713   return res;
18714 }
18715
18716 static bfd_boolean
18717 process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
18718 {
18719   Elf_External_Note * pnotes;
18720   Elf_External_Note * external;
18721   char * end;
18722   bfd_boolean res = TRUE;
18723
18724   if (length <= 0)
18725     return FALSE;
18726
18727   pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18728                                            _("v850 notes"));
18729   if (pnotes == NULL)
18730     return FALSE;
18731
18732   external = pnotes;
18733   end = (char*) pnotes + length;
18734
18735   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18736           (unsigned long) offset, (unsigned long) length);
18737
18738   while ((char *) external + sizeof (Elf_External_Note) < end)
18739     {
18740       Elf_External_Note * next;
18741       Elf_Internal_Note inote;
18742
18743       inote.type     = BYTE_GET (external->type);
18744       inote.namesz   = BYTE_GET (external->namesz);
18745       inote.namedata = external->name;
18746       inote.descsz   = BYTE_GET (external->descsz);
18747       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
18748       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18749
18750       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
18751         {
18752           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
18753           inote.descdata = inote.namedata;
18754           inote.namesz   = 0;
18755         }
18756
18757       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
18758
18759       if (   ((char *) next > end)
18760           || ((char *) next <  (char *) pnotes))
18761         {
18762           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18763                 (unsigned long) ((char *) external - (char *) pnotes));
18764           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18765                 inote.type, inote.namesz, inote.descsz);
18766           break;
18767         }
18768
18769       external = next;
18770
18771       /* Prevent out-of-bounds indexing.  */
18772       if (   inote.namedata + inote.namesz > end
18773           || inote.namedata + inote.namesz < inote.namedata)
18774         {
18775           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18776                 (unsigned long) ((char *) external - (char *) pnotes));
18777           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18778                 inote.type, inote.namesz, inote.descsz);
18779           break;
18780         }
18781
18782       printf ("  %s: ", get_v850_elf_note_type (inote.type));
18783
18784       if (! print_v850_note (& inote))
18785         {
18786           res = FALSE;
18787           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18788                   inote.namesz, inote.descsz);
18789         }
18790     }
18791
18792   free (pnotes);
18793
18794   return res;
18795 }
18796
18797 static bfd_boolean
18798 process_note_sections (Filedata * filedata)
18799 {
18800   Elf_Internal_Shdr * section;
18801   unsigned long i;
18802   unsigned int n = 0;
18803   bfd_boolean res = TRUE;
18804
18805   for (i = 0, section = filedata->section_headers;
18806        i < filedata->file_header.e_shnum && section != NULL;
18807        i++, section++)
18808     {
18809       if (section->sh_type == SHT_NOTE)
18810         {
18811           if (! process_notes_at (filedata, section,
18812                                   (bfd_vma) section->sh_offset,
18813                                   (bfd_vma) section->sh_size,
18814                                   (bfd_vma) section->sh_addralign))
18815             res = FALSE;
18816           n++;
18817         }
18818
18819       if ((   filedata->file_header.e_machine == EM_V800
18820            || filedata->file_header.e_machine == EM_V850
18821            || filedata->file_header.e_machine == EM_CYGNUS_V850)
18822           && section->sh_type == SHT_RENESAS_INFO)
18823         {
18824           if (! process_v850_notes (filedata,
18825                                     (bfd_vma) section->sh_offset,
18826                                     (bfd_vma) section->sh_size))
18827             res = FALSE;
18828           n++;
18829         }
18830     }
18831
18832   if (n == 0)
18833     /* Try processing NOTE segments instead.  */
18834     return process_corefile_note_segments (filedata);
18835
18836   return res;
18837 }
18838
18839 static bfd_boolean
18840 process_notes (Filedata * filedata)
18841 {
18842   /* If we have not been asked to display the notes then do nothing.  */
18843   if (! do_notes)
18844     return TRUE;
18845
18846   if (filedata->file_header.e_type != ET_CORE)
18847     return process_note_sections (filedata);
18848
18849   /* No program headers means no NOTE segment.  */
18850   if (filedata->file_header.e_phnum > 0)
18851     return process_corefile_note_segments (filedata);
18852
18853   printf (_("No note segments present in the core file.\n"));
18854   return TRUE;
18855 }
18856
18857 static unsigned char *
18858 display_public_gnu_attributes (unsigned char * start,
18859                                const unsigned char * const end)
18860 {
18861   printf (_("  Unknown GNU attribute: %s\n"), start);
18862
18863   start += strnlen ((char *) start, end - start);
18864   display_raw_attribute (start, end);
18865
18866   return (unsigned char *) end;
18867 }
18868
18869 static unsigned char *
18870 display_generic_attribute (unsigned char * start,
18871                            unsigned int tag,
18872                            const unsigned char * const end)
18873 {
18874   if (tag == 0)
18875     return (unsigned char *) end;
18876
18877   return display_tag_value (tag, start, end);
18878 }
18879
18880 static bfd_boolean
18881 process_arch_specific (Filedata * filedata)
18882 {
18883   if (! do_arch)
18884     return TRUE;
18885
18886   switch (filedata->file_header.e_machine)
18887     {
18888     case EM_ARC:
18889     case EM_ARC_COMPACT:
18890     case EM_ARC_COMPACT2:
18891       return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
18892                                  display_arc_attribute,
18893                                  display_generic_attribute);
18894     case EM_ARM:
18895       return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
18896                                  display_arm_attribute,
18897                                  display_generic_attribute);
18898
18899     case EM_MIPS:
18900     case EM_MIPS_RS3_LE:
18901       return process_mips_specific (filedata);
18902
18903     case EM_MSP430:
18904      return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
18905                                 display_msp430x_attribute,
18906                                 display_generic_attribute);
18907
18908     case EM_NDS32:
18909       return process_nds32_specific (filedata);
18910
18911     case EM_PPC:
18912     case EM_PPC64:
18913       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18914                                  display_power_gnu_attribute);
18915
18916     case EM_S390:
18917     case EM_S390_OLD:
18918       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18919                                  display_s390_gnu_attribute);
18920
18921     case EM_SPARC:
18922     case EM_SPARC32PLUS:
18923     case EM_SPARCV9:
18924       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18925                                  display_sparc_gnu_attribute);
18926
18927     case EM_TI_C6000:
18928       return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
18929                                  display_tic6x_attribute,
18930                                  display_generic_attribute);
18931
18932     default:
18933       return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
18934                                  display_public_gnu_attributes,
18935                                  display_generic_attribute);
18936     }
18937 }
18938
18939 static bfd_boolean
18940 get_file_header (Filedata * filedata)
18941 {
18942   /* Read in the identity array.  */
18943   if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
18944     return FALSE;
18945
18946   /* Determine how to read the rest of the header.  */
18947   switch (filedata->file_header.e_ident[EI_DATA])
18948     {
18949     default:
18950     case ELFDATANONE:
18951     case ELFDATA2LSB:
18952       byte_get = byte_get_little_endian;
18953       byte_put = byte_put_little_endian;
18954       break;
18955     case ELFDATA2MSB:
18956       byte_get = byte_get_big_endian;
18957       byte_put = byte_put_big_endian;
18958       break;
18959     }
18960
18961   /* For now we only support 32 bit and 64 bit ELF files.  */
18962   is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
18963
18964   /* Read in the rest of the header.  */
18965   if (is_32bit_elf)
18966     {
18967       Elf32_External_Ehdr ehdr32;
18968
18969       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
18970         return FALSE;
18971
18972       filedata->file_header.e_type      = BYTE_GET (ehdr32.e_type);
18973       filedata->file_header.e_machine   = BYTE_GET (ehdr32.e_machine);
18974       filedata->file_header.e_version   = BYTE_GET (ehdr32.e_version);
18975       filedata->file_header.e_entry     = BYTE_GET (ehdr32.e_entry);
18976       filedata->file_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
18977       filedata->file_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
18978       filedata->file_header.e_flags     = BYTE_GET (ehdr32.e_flags);
18979       filedata->file_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
18980       filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
18981       filedata->file_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
18982       filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
18983       filedata->file_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
18984       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
18985     }
18986   else
18987     {
18988       Elf64_External_Ehdr ehdr64;
18989
18990       /* If we have been compiled with sizeof (bfd_vma) == 4, then
18991          we will not be able to cope with the 64bit data found in
18992          64 ELF files.  Detect this now and abort before we start
18993          overwriting things.  */
18994       if (sizeof (bfd_vma) < 8)
18995         {
18996           error (_("This instance of readelf has been built without support for a\n\
18997 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18998           return FALSE;
18999         }
19000
19001       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
19002         return FALSE;
19003
19004       filedata->file_header.e_type      = BYTE_GET (ehdr64.e_type);
19005       filedata->file_header.e_machine   = BYTE_GET (ehdr64.e_machine);
19006       filedata->file_header.e_version   = BYTE_GET (ehdr64.e_version);
19007       filedata->file_header.e_entry     = BYTE_GET (ehdr64.e_entry);
19008       filedata->file_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
19009       filedata->file_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
19010       filedata->file_header.e_flags     = BYTE_GET (ehdr64.e_flags);
19011       filedata->file_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
19012       filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
19013       filedata->file_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
19014       filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
19015       filedata->file_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
19016       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
19017     }
19018
19019   if (filedata->file_header.e_shoff)
19020     {
19021       /* There may be some extensions in the first section header.  Don't
19022          bomb if we can't read it.  */
19023       if (is_32bit_elf)
19024         get_32bit_section_headers (filedata, TRUE);
19025       else
19026         get_64bit_section_headers (filedata, TRUE);
19027     }
19028
19029   return TRUE;
19030 }
19031
19032 static void
19033 close_file (Filedata * filedata)
19034 {
19035   if (filedata)
19036     {
19037       if (filedata->handle)
19038         fclose (filedata->handle);
19039       free (filedata);
19040     }
19041 }
19042
19043 void
19044 close_debug_file (void * data)
19045 {
19046   close_file ((Filedata *) data);
19047 }
19048
19049 static Filedata *
19050 open_file (const char * pathname)
19051 {
19052   struct stat  statbuf;
19053   Filedata *   filedata = NULL;
19054
19055   if (stat (pathname, & statbuf) < 0
19056       || ! S_ISREG (statbuf.st_mode))
19057     goto fail;
19058
19059   filedata = calloc (1, sizeof * filedata);
19060   if (filedata == NULL)
19061     goto fail;
19062
19063   filedata->handle = fopen (pathname, "rb");
19064   if (filedata->handle == NULL)
19065     goto fail;
19066
19067   filedata->file_size = (bfd_size_type) statbuf.st_size;
19068   filedata->file_name = pathname;
19069
19070   if (! get_file_header (filedata))
19071     goto fail;
19072
19073   if (filedata->file_header.e_shoff)
19074     {
19075       bfd_boolean res;
19076
19077       /* Read the section headers again, this time for real.  */
19078       if (is_32bit_elf)
19079         res = get_32bit_section_headers (filedata, FALSE);
19080       else
19081         res = get_64bit_section_headers (filedata, FALSE);
19082
19083       if (!res)
19084         goto fail;
19085     }
19086
19087   return filedata;
19088
19089  fail:
19090   if (filedata)
19091     {
19092       if (filedata->handle)
19093         fclose (filedata->handle);
19094       free (filedata);
19095     }
19096   return NULL;
19097 }
19098
19099 void *
19100 open_debug_file (const char * pathname)
19101 {
19102   return open_file (pathname);
19103 }
19104
19105 /* Process one ELF object file according to the command line options.
19106    This file may actually be stored in an archive.  The file is
19107    positioned at the start of the ELF object.  Returns TRUE if no
19108    problems were encountered, FALSE otherwise.  */
19109
19110 static bfd_boolean
19111 process_object (Filedata * filedata)
19112 {
19113   Filedata * separates;
19114   unsigned int i;
19115   bfd_boolean res = TRUE;
19116
19117   if (! get_file_header (filedata))
19118     {
19119       error (_("%s: Failed to read file header\n"), filedata->file_name);
19120       return FALSE;
19121     }
19122
19123   /* Initialise per file variables.  */
19124   for (i = ARRAY_SIZE (version_info); i--;)
19125     version_info[i] = 0;
19126
19127   for (i = ARRAY_SIZE (dynamic_info); i--;)
19128     dynamic_info[i] = 0;
19129   dynamic_info_DT_GNU_HASH = 0;
19130
19131   /* Process the file.  */
19132   if (show_name)
19133     printf (_("\nFile: %s\n"), filedata->file_name);
19134
19135   /* Initialise the dump_sects array from the cmdline_dump_sects array.
19136      Note we do this even if cmdline_dump_sects is empty because we
19137      must make sure that the dump_sets array is zeroed out before each
19138      object file is processed.  */
19139   if (filedata->num_dump_sects > cmdline.num_dump_sects)
19140     memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
19141
19142   if (cmdline.num_dump_sects > 0)
19143     {
19144       if (filedata->num_dump_sects == 0)
19145         /* A sneaky way of allocating the dump_sects array.  */
19146         request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
19147
19148       assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
19149       memcpy (filedata->dump_sects, cmdline.dump_sects,
19150               cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
19151     }
19152
19153   if (! process_file_header (filedata))
19154     return FALSE;
19155
19156   if (! process_section_headers (filedata))
19157     {
19158       /* Without loaded section headers we cannot process lots of things.  */
19159       do_unwind = do_version = do_dump = do_arch = FALSE;
19160
19161       if (! do_using_dynamic)
19162         do_syms = do_dyn_syms = do_reloc = FALSE;
19163     }
19164
19165   if (! process_section_groups (filedata))
19166     /* Without loaded section groups we cannot process unwind.  */
19167     do_unwind = FALSE;
19168
19169   if (process_program_headers (filedata))
19170     process_dynamic_section (filedata);
19171   else
19172     res = FALSE;
19173
19174   if (! process_relocs (filedata))
19175     res = FALSE;
19176
19177   if (! process_unwind (filedata))
19178     res = FALSE;
19179
19180   if (! process_symbol_table (filedata))
19181     res = FALSE;
19182
19183   if (! process_syminfo (filedata))
19184     res = FALSE;
19185
19186   if (! process_version_sections (filedata))
19187     res = FALSE;
19188
19189   if (filedata->file_header.e_shstrndx != SHN_UNDEF)
19190     separates = load_separate_debug_file (filedata, filedata->file_name);
19191   else
19192     separates = NULL;
19193
19194   if (! process_section_contents (filedata))
19195     res = FALSE;
19196
19197   if (separates)
19198     {
19199       if (! process_section_headers (separates))
19200         res = FALSE;
19201       else if (! process_section_contents (separates))
19202         res = FALSE;
19203     }
19204
19205   if (! process_notes (filedata))
19206     res = FALSE;
19207
19208   if (! process_gnu_liblist (filedata))
19209     res = FALSE;
19210
19211   if (! process_arch_specific (filedata))
19212     res = FALSE;
19213
19214   free (filedata->program_headers);
19215   filedata->program_headers = NULL;
19216
19217   free (filedata->section_headers);
19218   filedata->section_headers = NULL;
19219
19220   free (filedata->string_table);
19221   filedata->string_table = NULL;
19222   filedata->string_table_length = 0;
19223
19224   if (dynamic_strings)
19225     {
19226       free (dynamic_strings);
19227       dynamic_strings = NULL;
19228       dynamic_strings_length = 0;
19229     }
19230
19231   if (dynamic_symbols)
19232     {
19233       free (dynamic_symbols);
19234       dynamic_symbols = NULL;
19235       num_dynamic_syms = 0;
19236     }
19237
19238   if (dynamic_syminfo)
19239     {
19240       free (dynamic_syminfo);
19241       dynamic_syminfo = NULL;
19242     }
19243
19244   if (dynamic_section)
19245     {
19246       free (dynamic_section);
19247       dynamic_section = NULL;
19248     }
19249
19250   if (section_headers_groups)
19251     {
19252       free (section_headers_groups);
19253       section_headers_groups = NULL;
19254     }
19255
19256   if (section_groups)
19257     {
19258       struct group_list * g;
19259       struct group_list * next;
19260
19261       for (i = 0; i < group_count; i++)
19262         {
19263           for (g = section_groups [i].root; g != NULL; g = next)
19264             {
19265               next = g->next;
19266               free (g);
19267             }
19268         }
19269
19270       free (section_groups);
19271       section_groups = NULL;
19272     }
19273
19274   free_debug_memory ();
19275
19276   return res;
19277 }
19278
19279 /* Process an ELF archive.
19280    On entry the file is positioned just after the ARMAG string.
19281    Returns TRUE upon success, FALSE otherwise.  */
19282
19283 static bfd_boolean
19284 process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
19285 {
19286   struct archive_info arch;
19287   struct archive_info nested_arch;
19288   size_t got;
19289   bfd_boolean ret = TRUE;
19290
19291   show_name = TRUE;
19292
19293   /* The ARCH structure is used to hold information about this archive.  */
19294   arch.file_name = NULL;
19295   arch.file = NULL;
19296   arch.index_array = NULL;
19297   arch.sym_table = NULL;
19298   arch.longnames = NULL;
19299
19300   /* The NESTED_ARCH structure is used as a single-item cache of information
19301      about a nested archive (when members of a thin archive reside within
19302      another regular archive file).  */
19303   nested_arch.file_name = NULL;
19304   nested_arch.file = NULL;
19305   nested_arch.index_array = NULL;
19306   nested_arch.sym_table = NULL;
19307   nested_arch.longnames = NULL;
19308
19309   if (setup_archive (&arch, filedata->file_name, filedata->handle,
19310                      is_thin_archive, do_archive_index) != 0)
19311     {
19312       ret = FALSE;
19313       goto out;
19314     }
19315
19316   if (do_archive_index)
19317     {
19318       if (arch.sym_table == NULL)
19319         error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
19320       else
19321         {
19322           unsigned long i, l;
19323           unsigned long current_pos;
19324
19325           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
19326                   filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
19327
19328           current_pos = ftell (filedata->handle);
19329
19330           for (i = l = 0; i < arch.index_num; i++)
19331             {
19332               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
19333                 {
19334                   char * member_name;
19335
19336                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
19337
19338                   if (member_name != NULL)
19339                     {
19340                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
19341
19342                       if (qualified_name != NULL)
19343                         {
19344                           printf (_("Contents of binary %s at offset "), qualified_name);
19345                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
19346                           putchar ('\n');
19347                           free (qualified_name);
19348                         }
19349                     }
19350                 }
19351
19352               if (l >= arch.sym_size)
19353                 {
19354                   error (_("%s: end of the symbol table reached before the end of the index\n"),
19355                          filedata->file_name);
19356                   ret = FALSE;
19357                   break;
19358                 }
19359               /* PR 17531: file: 0b6630b2.  */
19360               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
19361               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
19362             }
19363
19364           if (arch.uses_64bit_indices)
19365             l = (l + 7) & ~ 7;
19366           else
19367             l += l & 1;
19368
19369           if (l < arch.sym_size)
19370             {
19371               error (ngettext ("%s: %ld byte remains in the symbol table, "
19372                                "but without corresponding entries in "
19373                                "the index table\n",
19374                                "%s: %ld bytes remain in the symbol table, "
19375                                "but without corresponding entries in "
19376                                "the index table\n",
19377                                arch.sym_size - l),
19378                      filedata->file_name, arch.sym_size - l);
19379               ret = FALSE;
19380             }
19381
19382           if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
19383             {
19384               error (_("%s: failed to seek back to start of object files in the archive\n"),
19385                      filedata->file_name);
19386               ret = FALSE;
19387               goto out;
19388             }
19389         }
19390
19391       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
19392           && !do_segments && !do_header && !do_dump && !do_version
19393           && !do_histogram && !do_debugging && !do_arch && !do_notes
19394           && !do_section_groups && !do_dyn_syms)
19395         {
19396           ret = TRUE; /* Archive index only.  */
19397           goto out;
19398         }
19399     }
19400
19401   while (1)
19402     {
19403       char * name;
19404       size_t namelen;
19405       char * qualified_name;
19406
19407       /* Read the next archive header.  */
19408       if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
19409         {
19410           error (_("%s: failed to seek to next archive header\n"), filedata->file_name);
19411           return FALSE;
19412         }
19413       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
19414       if (got != sizeof arch.arhdr)
19415         {
19416           if (got == 0)
19417             break;
19418           error (_("%s: failed to read archive header\n"), filedata->file_name);
19419           ret = FALSE;
19420           break;
19421         }
19422       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
19423         {
19424           error (_("%s: did not find a valid archive header\n"), arch.file_name);
19425           ret = FALSE;
19426           break;
19427         }
19428
19429       arch.next_arhdr_offset += sizeof arch.arhdr;
19430
19431       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
19432       if (archive_file_size & 01)
19433         ++archive_file_size;
19434
19435       name = get_archive_member_name (&arch, &nested_arch);
19436       if (name == NULL)
19437         {
19438           error (_("%s: bad archive file name\n"), filedata->file_name);
19439           ret = FALSE;
19440           break;
19441         }
19442       namelen = strlen (name);
19443
19444       qualified_name = make_qualified_name (&arch, &nested_arch, name);
19445       if (qualified_name == NULL)
19446         {
19447           error (_("%s: bad archive file name\n"), filedata->file_name);
19448           ret = FALSE;
19449           break;
19450         }
19451
19452       if (is_thin_archive && arch.nested_member_origin == 0)
19453         {
19454           /* This is a proxy for an external member of a thin archive.  */
19455           Filedata * member_filedata;
19456           char * member_file_name = adjust_relative_path
19457             (filedata->file_name, name, namelen);
19458
19459           if (member_file_name == NULL)
19460             {
19461               ret = FALSE;
19462               break;
19463             }
19464
19465           member_filedata = open_file (member_file_name);
19466           if (member_filedata == NULL)
19467             {
19468               error (_("Input file '%s' is not readable.\n"), member_file_name);
19469               free (member_file_name);
19470               ret = FALSE;
19471               break;
19472             }
19473
19474           archive_file_offset = arch.nested_member_origin;
19475           member_filedata->file_name = qualified_name;
19476
19477           if (! process_object (member_filedata))
19478             ret = FALSE;
19479
19480           close_file (member_filedata);
19481           free (member_file_name);
19482         }
19483       else if (is_thin_archive)
19484         {
19485           Filedata thin_filedata;
19486
19487           memset (&thin_filedata, 0, sizeof (thin_filedata));
19488
19489           /* PR 15140: Allow for corrupt thin archives.  */
19490           if (nested_arch.file == NULL)
19491             {
19492               error (_("%s: contains corrupt thin archive: %s\n"),
19493                      filedata->file_name, name);
19494               ret = FALSE;
19495               break;
19496             }
19497
19498           /* This is a proxy for a member of a nested archive.  */
19499           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
19500
19501           /* The nested archive file will have been opened and setup by
19502              get_archive_member_name.  */
19503           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
19504             {
19505               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
19506               ret = FALSE;
19507               break;
19508             }
19509
19510           thin_filedata.handle = nested_arch.file;
19511           thin_filedata.file_name = qualified_name;
19512
19513           if (! process_object (& thin_filedata))
19514             ret = FALSE;
19515         }
19516       else
19517         {
19518           archive_file_offset = arch.next_arhdr_offset;
19519           arch.next_arhdr_offset += archive_file_size;
19520
19521           filedata->file_name = qualified_name;
19522           if (! process_object (filedata))
19523             ret = FALSE;
19524         }
19525
19526       if (filedata->dump_sects != NULL)
19527         {
19528           free (filedata->dump_sects);
19529           filedata->dump_sects = NULL;
19530           filedata->num_dump_sects = 0;
19531         }
19532
19533       free (qualified_name);
19534     }
19535
19536  out:
19537   if (nested_arch.file != NULL)
19538     fclose (nested_arch.file);
19539   release_archive (&nested_arch);
19540   release_archive (&arch);
19541
19542   return ret;
19543 }
19544
19545 static bfd_boolean
19546 process_file (char * file_name)
19547 {
19548   Filedata * filedata = NULL;
19549   struct stat statbuf;
19550   char armag[SARMAG];
19551   bfd_boolean ret = TRUE;
19552
19553   if (stat (file_name, &statbuf) < 0)
19554     {
19555       if (errno == ENOENT)
19556         error (_("'%s': No such file\n"), file_name);
19557       else
19558         error (_("Could not locate '%s'.  System error message: %s\n"),
19559                file_name, strerror (errno));
19560       return FALSE;
19561     }
19562
19563   if (! S_ISREG (statbuf.st_mode))
19564     {
19565       error (_("'%s' is not an ordinary file\n"), file_name);
19566       return FALSE;
19567     }
19568
19569   filedata = calloc (1, sizeof * filedata);
19570   if (filedata == NULL)
19571     {
19572       error (_("Out of memory allocating file data structure\n"));
19573       return FALSE;
19574     }
19575
19576   filedata->file_name = file_name;
19577   filedata->handle = fopen (file_name, "rb");
19578   if (filedata->handle == NULL)
19579     {
19580       error (_("Input file '%s' is not readable.\n"), file_name);
19581       free (filedata);
19582       return FALSE;
19583     }
19584
19585   if (fread (armag, SARMAG, 1, filedata->handle) != 1)
19586     {
19587       error (_("%s: Failed to read file's magic number\n"), file_name);
19588       fclose (filedata->handle);
19589       free (filedata);
19590       return FALSE;
19591     }
19592
19593   filedata->file_size = (bfd_size_type) statbuf.st_size;
19594
19595   if (memcmp (armag, ARMAG, SARMAG) == 0)
19596     {
19597       if (! process_archive (filedata, FALSE))
19598         ret = FALSE;
19599     }
19600   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
19601     {
19602       if ( ! process_archive (filedata, TRUE))
19603         ret = FALSE;
19604     }
19605   else
19606     {
19607       if (do_archive_index)
19608         error (_("File %s is not an archive so its index cannot be displayed.\n"),
19609                file_name);
19610
19611       rewind (filedata->handle);
19612       archive_file_size = archive_file_offset = 0;
19613
19614       if (! process_object (filedata))
19615         ret = FALSE;
19616     }
19617
19618   fclose (filedata->handle);
19619   free (filedata);
19620
19621   return ret;
19622 }
19623
19624 #ifdef SUPPORT_DISASSEMBLY
19625 /* Needed by the i386 disassembler.  For extra credit, someone could
19626    fix this so that we insert symbolic addresses here, esp for GOT/PLT
19627    symbols.  */
19628
19629 void
19630 print_address (unsigned int addr, FILE * outfile)
19631 {
19632   fprintf (outfile,"0x%8.8x", addr);
19633 }
19634
19635 /* Needed by the i386 disassembler.  */
19636
19637 void
19638 db_task_printsym (unsigned int addr)
19639 {
19640   print_address (addr, stderr);
19641 }
19642 #endif
19643
19644 int
19645 main (int argc, char ** argv)
19646 {
19647   int err;
19648
19649 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19650   setlocale (LC_MESSAGES, "");
19651 #endif
19652 #if defined (HAVE_SETLOCALE)
19653   setlocale (LC_CTYPE, "");
19654 #endif
19655   bindtextdomain (PACKAGE, LOCALEDIR);
19656   textdomain (PACKAGE);
19657
19658   expandargv (&argc, &argv);
19659
19660   cmdline.file_name = "<cmdline>";
19661   parse_args (& cmdline, argc, argv);
19662
19663   if (optind < (argc - 1))
19664     show_name = TRUE;
19665   else if (optind >= argc)
19666     {
19667       warn (_("Nothing to do.\n"));
19668       usage (stderr);
19669     }
19670
19671   err = FALSE;
19672   while (optind < argc)
19673     if (! process_file (argv[optind++]))
19674       err = TRUE;
19675
19676   if (cmdline.dump_sects != NULL)
19677     free (cmdline.dump_sects);
19678
19679   return err ? EXIT_FAILURE : EXIT_SUCCESS;
19680 }